change lock

Bumps [docker/login-action](https://github.com/docker/login-action) from 1 to 1.9.0.
- [Release notes](https://github.com/docker/login-action/releases)
- [Commits](https://github.com/docker/login-action/compare/v1...v1.9.0)

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.circleci/config.yml

@@ -1,168 +0,0 @@
-version: 2.1
-
-executors:
-  golang:
-    docker:
-      - image: tendermintdev/docker-tendermint-build
-    working_directory: /go/src/github.com/tendermint/tendermint
-    environment:
-      GOBIN: /tmp/bin
-  release:
-    machine: true
-  docs:
-    docker:
-      - image: tendermintdev/docker-website-deployment
-    environment:
-      AWS_REGION: us-east-1
-
-commands:
-  run_test:
-    parameters:
-      script_path:
-        type: string
-    steps:
-      - attach_workspace:
-          at: /tmp/bin
-      - restore_cache:
-          name: "Restore source code cache"
-          keys:
-            - go-src-v1-{{ .Revision }}
-      - checkout
-      - restore_cache:
-          name: "Restore go modules cache"
-          keys:
-            - go-mod-v1-{{ checksum "go.sum" }}
-      - run:
-          name: "Running test"
-          command: |
-            bash << parameters.script_path >>
-jobs:
-  setup_dependencies:
-    executor: golang
-    steps:
-      - checkout
-      - restore_cache:
-          name: "Restore go modules cache"
-          keys:
-            - go-mod-v1-{{ checksum "go.sum" }}
-      - run:
-          command: |
-            mkdir -p /tmp/bin
-      - run:
-          name: Cache go modules
-          command: make go-mod-cache
-      - run:
-          name: tools
-          command: make tools
-      - run:
-          name: "Build binaries"
-          command: make install install_abci
-      - save_cache:
-          name: "Save go modules cache"
-          key: go-mod-v1-{{ checksum "go.sum" }}
-          paths:
-            - "/go/pkg/mod"
-      - save_cache:
-          name: "Save source code cache"
-          key: go-src-v1-{{ .Revision }}
-          paths:
-            - ".git"
-      - persist_to_workspace:
-          root: "/tmp/bin"
-          paths:
-            - "."
-
-  deploy_docs:
-    executor: docs
-    steps:
-      - checkout
-      - run:
-          name: "Pull versions"
-          command: git fetch origin v0.32 v0.33
-      - run:
-          name: "Build docs"
-          command: make build-docs
-      - run:
-          name: "Sync to S3"
-          command: make sync-docs
-
-  prepare_build:
-    executor: golang
-    steps:
-      - restore_cache:
-          name: "Restore source code cache"
-          keys:
-            - go-src-v1-{{ .Revision }}
-      - checkout
-      - run:
-          name: Get next release number
-          command: |
-            export LAST_TAG="`git describe --tags --abbrev=0 --match "${CIRCLE_BRANCH}.*"`"
-            echo "Last tag: ${LAST_TAG}"
-            if [ -z "${LAST_TAG}" ]; then
-              export LAST_TAG="${CIRCLE_BRANCH}"
-              echo "Last tag not found. Possibly fresh branch or feature branch. Setting ${LAST_TAG} as tag."
-            fi
-            export NEXT_TAG="`python -u scripts/release_management/bump-semver.py --version "${LAST_TAG}"`"
-            echo "Next tag: ${NEXT_TAG}"
-            echo "export CIRCLE_TAG=\"${NEXT_TAG}\"" > release-version.source
-      - run:
-          name: Build dependencies
-          command: make tools
-      - persist_to_workspace:
-          root: .
-          paths:
-            - "release-version.source"
-      - save_cache:
-          key: v2-release-deps-{{ checksum "go.sum" }}
-          paths:
-            - "/go/pkg/mod"
-
-  # # Test RPC implementation against the swagger documented specs
-  # contract_tests:
-  #   working_directory: /home/circleci/.go_workspace/src/github.com/tendermint/tendermint
-  #   machine:
-  #     image: circleci/classic:latest
-  #   environment:
-  #     GOBIN: /home/circleci/.go_workspace/bin
-  #     GOPATH: /home/circleci/.go_workspace/
-  #     GOOS: linux
-  #     GOARCH: amd64
-  #   parallelism: 1
-  #   steps:
-  #     - checkout
-  #     - run:
-  #         name: Test RPC endpoints against swagger documentation
-  #         command: |
-  #           set -x
-  #           export PATH=~/.local/bin:$PATH
-  #           # install node and dredd
-  #           ./scripts/get_nodejs.sh
-  #           # build the binaries with a proper version of Go
-  #           docker run --rm -v "$PWD":/go/src/github.com/tendermint/tendermint -w /go/src/github.com/tendermint/tendermint golang make build-linux build-contract-tests-hooks
-  #           # This docker image works with go 1.7, we can install here the hook handler that contract-tests is going to use
-  #           go get github.com/snikch/goodman/cmd/goodman
-  #           make contract-tests
-
-workflows:
-  version: 2
-  docs:
-    jobs:
-      - deploy_docs:
-          context: tendermint-docs
-          filters:
-            branches:
-              only:
-                - master
-            tags:
-              only:
-                - /^v.*/
-      - deploy_docs:
-          context: tendermint-docs-staging
-          filters:
-            branches:
-              only:
-                - docs-staging
-      # - contract_tests:
-      #     requires:
-      #       - setup_dependencies

.github/CODEOWNERS

@@ -7,4 +7,5 @@
 # global owners are only requested if there isn't a more specific
 # codeowner specified below. For this reason, the global codeowners
 # are often repeated in package-level definitions.
-*      @ebuchman @cmwaters @tychoish @williambanfield @creachadair
+*       @alexanderbez @ebuchman @cmwaters @tessr @tychoish
+

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,7 +1,7 @@
-## Description
+Please add a description of the changes that this PR introduces and the files that
+are the most critical to review.
 
-_Please add a description of the changes that this PR introduces and the files that
-are the most critical to review._ 
+If this PR fixes an open Issue, please include "Closes #XXX" (where "XXX" is the Issue number) 
+so that GitHub will automatically close the Issue when this PR is merged.
 
-Closes: #XXX
 

.github/codecov.yml

@@ -2,9 +2,6 @@ coverage:
   precision: 2
   round: down
   range: "70...100"
-  github_checks:
-    annotations: false
-
   status:
     project:
       default:
@@ -12,6 +9,9 @@ coverage:
     patch: on
     changes: off
 
+github_checks:
+  annotations: false
+
 comment:
   layout: "diff, files"
   behavior: default

.github/dependabot.yml

@@ -0,0 +1,27 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: daily
+      time: "11:00"
+    open-pull-requests-limit: 10
+  - package-ecosystem: npm
+    directory: "/docs"
+    schedule:
+      interval: daily
+      time: "11:00"
+    open-pull-requests-limit: 10
+    reviewers:
+      - fadeev
+  - package-ecosystem: gomod
+    directory: "/"
+    schedule:
+      interval: daily
+      time: "11:00"
+    open-pull-requests-limit: 10
+    reviewers:
+      - melekes
+      - tessr
+    labels:
+      - T:dependencies

.github/mergify.yml

@@ -1,19 +1,18 @@
-queue_rules:
-  - name: default
-    conditions:
-      - base=v0.34.x
-      - label=S:automerge
-
 pull_request_rules:
-  - name: Automerge to v0.34.x
+  - name: Automerge to master
     conditions:
-      - base=v0.34.x
+      - base=master
       - label=S:automerge
     actions:
-      queue:
+      merge:
         method: squash
-        name: default
-        commit_message_template: |
-          {{ title }} (#{{ number }})
-
-          {{ body }}
+        strict: true
+        commit_message: title+body
+  - name: backport patches to v0.34.x branch
+    conditions:
+      - base=master
+      - label=S:backport-to-v0.34.x
+    actions:
+      backport:
+        branches:
+          - v0.34.x

.github/workflows/check-generated.yml

@@ -1,75 +0,0 @@
-# Verify that generated code is up-to-date.
-#
-# Note that we run these checks regardless whether the input files have
-# changed, because generated code can change in response to toolchain updates
-# even if no files in the repository are modified.
-name: Check generated code
-on:
-  pull_request:
-    branches:
-      - v0.34.x
-
-permissions:
-  contents: read
-
-jobs:
-  check-mocks:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '1.17'
-
-      - uses: actions/checkout@v3
-
-      - name: "Check generated mocks"
-        run: |
-          set -euo pipefail
-
-          readonly MOCKERY=2.12.3  # N.B. no leading "v"
-          curl -sL "https://github.com/vektra/mockery/releases/download/v${MOCKERY}/mockery_${MOCKERY}_Linux_x86_64.tar.gz" | tar -C /usr/local/bin -xzf -
-          make mockery 2>/dev/null
-
-          if ! git diff --stat --exit-code ; then
-            echo ">> ERROR:"
-            echo ">>"
-            echo ">> Generated mocks require update (either Mockery or source files may have changed)."
-            echo ">> Ensure your tools are up-to-date, re-run 'make mockery' and update this PR."
-            echo ">>"
-            exit 1
-          fi
-
-  check-proto:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '1.17'
-
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 1  # we need a .git directory to run git diff
-
-      - name: "Check protobuf generated code"
-        run: |
-          set -euo pipefail
-
-          # Install buf and gogo tools, so that differences that arise from
-          # toolchain differences are also caught.
-          readonly tools="$(mktemp -d)"
-          export PATH="${PATH}:${tools}/bin"
-          export GOBIN="${tools}/bin"
-
-          go install github.com/bufbuild/buf/cmd/buf
-          go install github.com/gogo/protobuf/protoc-gen-gogofaster@latest
-
-          make proto-gen
-
-          if ! git diff --stat --exit-code ; then
-            echo ">> ERROR:"
-            echo ">>"
-            echo ">> Protobuf generated code requires update (either tools or .proto files may have changed)."
-            echo ">> Ensure your tools are up-to-date, re-run 'make proto-gen' and update this PR."
-            echo ">>"
-            exit 1
-          fi

.github/workflows/coverage.yml

@@ -10,25 +10,25 @@ jobs:
   split-test-files:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2.3.4
       - name: Create a file with all the pkgs
         run: go list ./... > pkgs.txt
       - name: Split pkgs into 4 files
         run: split -d -n l/4 pkgs.txt pkgs.txt.part.
       # cache multiple
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v2
         with:
           name: "${{ github.sha }}-00"
           path: ./pkgs.txt.part.00
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v2
         with:
           name: "${{ github.sha }}-01"
           path: ./pkgs.txt.part.01
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v2
         with:
           name: "${{ github.sha }}-02"
           path: ./pkgs.txt.part.02
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v2
         with:
           name: "${{ github.sha }}-03"
           path: ./pkgs.txt.part.03
@@ -42,11 +42,11 @@ jobs:
         goarch: ["arm", "amd64"]
     timeout-minutes: 5
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
@@ -64,25 +64,29 @@ jobs:
       matrix:
         part: ["00", "01", "02", "03"]
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
             go.mod
             go.sum
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v2
         with:
           name: "${{ github.sha }}-${{ matrix.part }}"
         if: env.GIT_DIFF
+      - name: Set up Go
+        uses: actions/setup-go@v2
+        with:
+          go-version: 1.16
       - name: test & coverage report creation
         run: |
           cat pkgs.txt.part.${{ matrix.part }} | xargs go test -mod=readonly -timeout 8m -race -coverprofile=${{ matrix.part }}profile.out -covermode=atomic
         if: env.GIT_DIFF
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v2
         with:
           name: "${{ github.sha }}-${{ matrix.part }}-coverage"
           path: ./${{ matrix.part }}profile.out
@@ -91,33 +95,33 @@ jobs:
     runs-on: ubuntu-latest
     needs: tests
     steps:
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
             go.mod
             go.sum
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v2
         with:
           name: "${{ github.sha }}-00-coverage"
         if: env.GIT_DIFF
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v2
         with:
           name: "${{ github.sha }}-01-coverage"
         if: env.GIT_DIFF
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v2
         with:
           name: "${{ github.sha }}-02-coverage"
         if: env.GIT_DIFF
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v2
         with:
           name: "${{ github.sha }}-03-coverage"
         if: env.GIT_DIFF
       - run: |
           cat ./*profile.out | grep -v "mode: atomic" >> coverage.txt
         if: env.GIT_DIFF
-      - uses: codecov/codecov-action@v3
+      - uses: codecov/codecov-action@v1.5.0
         with:
           file: ./coverage.txt
         if: env.GIT_DIFF

.github/workflows/docker.yml

@@ -14,7 +14,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2.3.4
       - name: Prepare
         id: prep
         run: |
@@ -40,17 +40,17 @@ jobs:
           platforms: all
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v1.3.0
 
       - name: Login to DockerHub
         if: ${{ github.event_name != 'pull_request' }}
-        uses: docker/login-action@v2
+        uses: docker/login-action@v1.9.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Publish to Docker Hub
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v2.4.0
         with:
           context: .
           file: ./DOCKER/Dockerfile

.github/workflows/docs.yml

@@ -0,0 +1,32 @@
+name: Documentation
+# This job builds and deploys documentation to github pages.
+# It runs on every push to master, and can be manually triggered.
+on:
+  workflow_dispatch: # allow running workflow manually
+  push:
+    branches:
+      - master
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    container:
+      image: tendermintdev/docker-website-deployment
+    steps:
+      - name: Checkout 🛎️
+        uses: actions/checkout@v2.3.4
+        with:
+          persist-credentials: false
+          fetch-depth: 0
+
+      - name: Install and Build 🔧
+        run: |
+          apk add rsync
+          make build-docs
+
+      - name: Deploy 🚀
+        uses: JamesIves/github-pages-deploy-action@4.1.2
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          BRANCH: gh-pages
+          FOLDER: ~/output

.github/workflows/e2e-manual.yml

@@ -1,35 +0,0 @@
-# Manually run randomly generated E2E testnets (as nightly).
-name: e2e-manual
-on:
-  workflow_dispatch:
-
-jobs:
-  e2e-nightly-test:
-    # Run parallel jobs for the listed testnet groups (must match the
-    # ./build/generator -g flag)
-    strategy:
-      fail-fast: false
-      matrix:
-        group: ['00', '01', '02', '03']
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '1.17'
-
-      - uses: actions/checkout@v3
-
-      - name: Build
-        working-directory: test/e2e
-        # Run make jobs in parallel, since we can't run steps in parallel.
-        run: make -j2 docker generator runner tests
-
-      - name: Generate testnets
-        working-directory: test/e2e
-        # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 4 -d networks/nightly/
-
-      - name: Run ${{ matrix.p2p }} p2p testnets
-        working-directory: test/e2e
-        run: ./run-multiple.sh networks/nightly/*-group${{ matrix.group }}-*.toml

.github/workflows/e2e-nightly-34x.yml

@@ -21,11 +21,11 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '^1.15.4'
+          go-version: '1.16'
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2.3.4
         with:
           ref: 'v0.34.x'
 

.github/workflows/e2e-nightly-master.yml

@@ -16,15 +16,16 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
+        p2p: ['legacy', 'new', 'hybrid']
         group: ['00', '01', '02', '03']
     runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '1.15'
+          go-version: '1.16'
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2.3.4
 
       - name: Build
         working-directory: test/e2e
@@ -34,11 +35,11 @@ jobs:
       - name: Generate testnets
         working-directory: test/e2e
         # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 4 -d networks/nightly
+        run: ./build/generator -g 4 -d networks/nightly/${{ matrix.p2p }} -p ${{ matrix.p2p }} 
 
-      - name: Run testnets in group ${{ matrix.group }}
+      - name: Run ${{ matrix.p2p }} p2p testnets in group ${{ matrix.group }}
         working-directory: test/e2e
-        run: ./run-multiple.sh networks/nightly/*-group${{ matrix.group }}-*.toml
+        run: ./run-multiple.sh networks/nightly/${{ matrix.p2p }}/*-group${{ matrix.group }}-*.toml
 
   e2e-nightly-fail-2:
     needs: e2e-nightly-test-2

.github/workflows/e2e.yml

@@ -2,6 +2,7 @@ name: e2e
 # Runs the CI end-to-end test network on all pushes to master or release branches
 # and every pull request, but only if any Go files have been changed.
 on:
+  workflow_dispatch: # allow running workflow manually
   pull_request:
   push:
     branches:
@@ -13,11 +14,11 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '^1.15.4'
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: '1.16'
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go

.github/workflows/fuzz-nightly.yml

@@ -4,16 +4,20 @@ on:
   workflow_dispatch: # allow running workflow manually
   schedule:
     - cron: '0 3 * * *'
+  pull_request:
+    branches: [master]
+    paths:
+      - "test/fuzz/**/*.go"
 
 jobs:
   fuzz-nightly-test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '1.15'
+          go-version: '1.16'
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2.3.4
 
       - name: Install go-fuzz
         working-directory: test/fuzz
@@ -45,18 +49,18 @@ jobs:
         continue-on-error: true
 
       - name: Archive crashers
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v2
         with:
           name: crashers
           path: test/fuzz/**/crashers
-          retention-days: 1
+          retention-days: 3
 
       - name: Archive suppressions
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v2
         with:
           name: suppressions
           path: test/fuzz/**/suppressions
-          retention-days: 1
+          retention-days: 3
 
       - name: Set crashers count
         working-directory: test/fuzz

.github/workflows/janitor.yml

@@ -0,0 +1,16 @@
+name: Janitor
+# Janitor cleans up previous runs of various workflows
+# To add more workflows to cancel visit https://api.github.com/repos/tendermint/tendermint/actions/workflows and find the actions name
+on:
+  pull_request:
+
+jobs:
+  cancel:
+    name: "Cancel Previous Runs"
+    runs-on: ubuntu-latest
+    timeout-minutes: 3
+    steps:
+      - uses: styfle/cancel-workflow-action@0.9.0
+        with:
+          workflow_id: 1041851,1401230,2837803
+          access_token: ${{ github.token }}

.github/workflows/jepsen.yml

@@ -0,0 +1,65 @@
+# Runs a Jepsen test - cas-register (no nemesis) by default.
+#   See inputs for various options.
+#   Repo: https://github.com/tendermint/jepsen
+#
+# If you want to test a new breaking version of Tendermint, you'll need to
+# update the Merkleeyes ABCI app and 'merkleeyesUrl' input accordingly. You can
+# upload a new tarball to
+# https://github.com/tendermint/jepsen/releases/tag/0.2.1.
+#
+# Manually triggered.
+name: jepsen
+on:
+  workflow_dispatch:
+    inputs:
+      workload:
+        description: 'Test workload to run: (cas-register | set)'
+        required: true
+        default: 'cas-register'
+      nemesis:
+        description: 'Nemesis to use: (none | clocks | single-partitions | half-partitions | ring-partitions | split-dup-validators | peekaboo-dup-validators | changing-validators | crash | truncate-tendermint | truncate-merkleeyes)'
+        required: true
+        default: 'none'
+      dupOrSuperByzValidators:
+        description: '"--dup-validators" (multiple validators share the same key) and(or) "--super-byzantine-validators" (byzantine validators have just shy of 2/3 the voting weight)'
+        required: false
+        default: ''
+      concurrency:
+        description: 'How many workers should we run? Must be an integer and >= 10, optionally followed by n (e.g. 3n) to multiply by the number of nodes.'
+        required: true
+        default: 10
+      timeLimit:
+        description: 'Excluding setup and teardown, how long should a test run for, in seconds?'
+        required: true
+        default: 60
+      tendermintUrl:
+        description: 'Where to grab the Tendermint tarball (w/ linux/amd64 binary)'
+        required: true
+        default: 'https://github.com/melekes/katas/releases/download/0.2.0/tendermint.tar.gz'
+      merkleeyesUrl:
+        description: 'Where to grab the Merkleeyes tarball (w/ linux/amd64 binary)'
+        required: true
+        default: 'https://github.com/tendermint/jepsen/releases/download/0.2.1/merkleeyes_0.1.7.tar.gz'
+
+jobs:
+  jepsen-test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the Jepsen repository
+        uses: actions/checkout@v2.3.4
+        with:
+          repository: 'tendermint/jepsen'
+
+      - name: Start a Jepsen cluster in background
+        working-directory: docker
+        run: ./bin/up --daemon
+
+      - name: Run the test
+        run: docker exec -i jepsen-control bash -c 'source /root/.bashrc; cd /jepsen/tendermint; lein run test --nemesis ${{ github.event.inputs.nemesis }} --workload ${{ github.event.inputs.workload }} --concurrency ${{ github.event.inputs.concurrency }} --tendermint-url ${{ github.event.inputs.tendermintUrl }} --merkleeyes-url ${{ github.event.inputs.merkleeyesUrl }} --time-limit ${{ github.event.inputs.timeLimit }} ${{ github.event.inputs.dupOrSuperByzValidators }}'
+
+      - name: Archive results
+        uses: actions/upload-artifact@v2
+        with:
+          name: results
+          path: tendermint/store/latest
+          retention-days: 3

.github/workflows/linkchecker.yml

@@ -1,12 +1,12 @@
 name: Check Markdown links
-on:
+on: 
   schedule:
     - cron: '* */24 * * *'
 jobs:
   markdown-link-check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: creachadair/github-action-markdown-link-check@master
+      - uses: actions/checkout@v2.3.4
+      - uses: gaurav-nelson/github-action-markdown-link-check@1.0.12
         with:
           folder-path: "docs"

.github/workflows/lint.yml

@@ -13,20 +13,17 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 8
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '^1.16'
-      - uses: technote-space/get-diff-action@v6
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
             go.mod
             go.sum
-      - uses: golangci/golangci-lint-action@v3
+      - uses: golangci/golangci-lint-action@v2.5.2
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.45
+          version: v1.38
           args: --timeout 10m
           github-token: ${{ secrets.github_token }}
         if: env.GIT_DIFF

.github/workflows/linter.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2.3.4
       - name: Lint Code Base
         uses: docker://github/super-linter:v3
         env:

.github/workflows/proto-docker.yml

@@ -0,0 +1,51 @@
+name: Build & Push TM Proto Builder
+on:
+  pull_request:
+    paths:
+      - "tools/proto/*"
+  push:
+    branches:
+      - master
+    paths:
+      - "tools/proto/*"
+  schedule:
+    # run this job once a month to recieve any go or buf updates
+    - cron: "* * 1 * *"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2.3.4
+      - name: Prepare
+        id: prep
+        run: |
+          DOCKER_IMAGE=tendermintdev/docker-build-proto
+          VERSION=noop
+          if [[ $GITHUB_REF == refs/tags/* ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          elif [[ $GITHUB_REF == refs/heads/* ]]; then
+            VERSION=$(echo ${GITHUB_REF#refs/heads/} | sed -r 's#/+#-#g')
+            if [ "${{ github.event.repository.default_branch }}" = "$VERSION" ]; then
+              VERSION=latest
+            fi
+          fi
+          TAGS="${DOCKER_IMAGE}:${VERSION}"
+          echo ::set-output name=tags::${TAGS}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1.3.0
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1.9.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Publish to Docker Hub
+        uses: docker/build-push-action@v2.4.0
+        with:
+          context: ./tools/proto
+          file: ./tools/proto/Dockerfile
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.prep.outputs.tags }}

.github/workflows/proto-lint.yml

@@ -1,21 +0,0 @@
-name: Protobuf Lint
-on:
-  pull_request:
-    paths:
-      - 'proto/**'
-  push:
-    branches:
-      - v0.34.x
-    paths:
-      - 'proto/**'
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - uses: actions/checkout@v3
-      - uses: bufbuild/buf-setup-action@v1.6.0
-      - uses: bufbuild/buf-lint-action@v1
-        with:
-          input: 'proto'

.github/workflows/proto.yml

@@ -2,6 +2,7 @@ name: Protobuf
 # Protobuf runs buf (https://buf.build/) lint and check-breakage
 # This workflow is only run when a .proto file has been modified
 on:
+  workflow_dispatch: # allow running workflow manually
   pull_request:
     paths:
       - "**.proto"
@@ -10,13 +11,13 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 4
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2.3.4
       - name: lint
         run: make proto-lint
   proto-breakage:
     runs-on: ubuntu-latest
     timeout-minutes: 4
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2.3.4
       - name: check-breakage
         run: make proto-check-breaking-ci

.github/workflows/release.yml

@@ -2,6 +2,8 @@ name: "Release"
 
 on:
   push:
+    branches: 
+      - "RC[0-9]/**"
     tags:
       - "v[0-9]+.[0-9]+.[0-9]+" # Push events to matching v*, i.e. v1.0, v20.15.10
 
@@ -10,18 +12,27 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2.3.4
         with:
           fetch-depth: 0
 
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '^1.15.4'
+          go-version: '1.16'
 
       - run: echo https://github.com/tendermint/tendermint/blob/${GITHUB_REF#refs/tags/}/CHANGELOG.md#${GITHUB_REF#refs/tags/} > ../release_notes.md 
+        if: startsWith(github.ref, 'refs/tags/')
 
-      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v3
+      - name: Build
+        uses: goreleaser/goreleaser-action@v2
+        if: ${{ github.event_name == 'pull_request' }}
+        with:
+          version: latest
+          args: build --skip-validate   # skip validate skips initial sanity checks in order to be able to fully run
+
+      - name: Release
+        uses: goreleaser/goreleaser-action@v2
+        if: startsWith(github.ref, 'refs/tags/')
         with:
           version: latest
           args: release --rm-dist --release-notes=../release_notes.md

.github/workflows/stale.yml

@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v5
+      - uses: actions/stale@v3.0.18
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           stale-pr-message: "This pull request has been automatically marked as stale because it has not had

.github/workflows/tests.yml

@@ -10,24 +10,16 @@ on:
       - release/**
 
 jobs:
-  cleanup-runs:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: rokroskar/workflow-run-cleanup-action@master
-        env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-    if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/master'"
-
   build:
     name: Build
     runs-on: ubuntu-latest
     timeout-minutes: 5
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
@@ -36,7 +28,7 @@ jobs:
       - name: install
         run: make install install_abci
         if: "env.GIT_DIFF != ''"
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
@@ -44,7 +36,7 @@ jobs:
             ${{ runner.os }}-go-
         if: env.GIT_DIFF
       # Cache binaries for use by other jobs
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/bin
           key: ${{ runner.os }}-${{ github.sha }}-tm-binary
@@ -55,24 +47,24 @@ jobs:
     needs: build
     timeout-minutes: 5
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
             go.mod
             go.sum
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-go-
         if: env.GIT_DIFF
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/bin
           key: ${{ runner.os }}-${{ github.sha }}-tm-binary
@@ -87,24 +79,24 @@ jobs:
     needs: build
     timeout-minutes: 5
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
             go.mod
             go.sum
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-go-
         if: env.GIT_DIFF
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/bin
           key: ${{ runner.os }}-${{ github.sha }}-tm-binary
@@ -118,24 +110,24 @@ jobs:
     needs: build
     timeout-minutes: 5
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
             go.mod
             go.sum
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-go-
         if: env.GIT_DIFF
-      - uses: actions/cache@v3
+      - uses: actions/cache@v2.1.5
         with:
           path: ~/go/bin
           key: ${{ runner.os }}-${{ github.sha }}-tm-binary

.gitignore

@@ -1,55 +1,44 @@
-*.swp
-*.swo
-.bak
 *.bak
+*.iml
+*.log
+*.swo
+*.swp
+*/.glide
+*/vendor
 .DS_Store
-build/*
-rpc/test/.tendermint
-.tendermint
-remote_dump
+.bak
+.idea/
 .revision
-vendor
+.tendermint
+.tendermint-lite
+.terraform
 .vagrant
-test/e2e/build
-test/maverick/maverick
-test/e2e/networks/*/
-test/p2p/data/
-test/logs
+.vendor-new/
+.vscode/
+abci-cli
+addrbook.json
+artifacts/*
+build/*
 coverage.txt
+docs/.vuepress/dist
 docs/_build
 docs/dist
-docs/.vuepress/dist
-*.log
-abci-cli
 docs/node_modules/
 index.html.md
-
-scripts/wal2json/wal2json
-scripts/cutWALUntil/cutWALUntil
-
-.idea/
-*.iml
-
-.vscode/
-
 libs/pubsub/query/fuzz_test/output
+profile\.out
+remote_dump
+rpc/test/.tendermint
+scripts/cutWALUntil/cutWALUntil
+scripts/wal2json/wal2json
 shunit2
-
-.tendermint-lite
-addrbook.json
-
-*/vendor
-.vendor-new/
-*/.glide
-.terraform
 terraform.tfstate
 terraform.tfstate.backup
 terraform.tfstate.d
-profile\.out
+test/app/grpc_client
 test/e2e/build
 test/e2e/networks/*/
 test/logs
-test/maverick/maverick
 test/p2p/data/
 vendor
 test/fuzz/**/corpus

.golangci.yml

@@ -1,45 +1,44 @@
 linters:
   enable:
-    - asciicheck
     - bodyclose
     - deadcode
     - depguard
     - dogsled
     - dupl
     - errcheck
-    - exportloopref
     # - funlen
     # - gochecknoglobals
     # - gochecknoinits
-    # - gocognit
     - goconst
-    # - gocritic
+    - gocritic
     # - gocyclo
     # - godox
     - gofmt
     - goimports
-    - revive
+    - golint
     - gosec
     - gosimple
     - govet
     - ineffassign
     # - interfacer
     - lll
+    - misspell
     # - maligned
-    # - misspell
     - nakedret
-    - nolintlint
     - prealloc
+    - scopelint
     - staticcheck
     - structcheck
     - stylecheck
-    # - typecheck
+    - typecheck
     - unconvert
     # - unparam
     - unused
     - varcheck
     # - whitespace
     # - wsl
+    # - gocognit
+    - nolintlint
 
 issues:
   exclude-rules:
@@ -54,17 +53,9 @@ issues:
 linters-settings:
   dogsled:
     max-blank-identifiers: 3
-  maligned:
-    suggest-new: true
-  # govet:
-  #   check-shadowing: true
-  revive:
+  golint:
     min-confidence: 0
   maligned:
     suggest-new: true
   misspell:
     locale: US
-    ignore-words:
-      - behaviour
-
-

.goreleaser.yml

@@ -5,7 +5,7 @@ env:
   - GO111MODULE=on
 
 builds:
-  - id: "Tendermint"
+  - id: "tendermint"
     main: ./cmd/tendermint/main.go
     ldflags:
       - -s -w -X github.com/tendermint/tendermint/version.TMCoreSemVer={{ .Version }}
@@ -26,3 +26,11 @@ checksum:
 
 release:
   name_template: "{{.Version}} (WARNING: BETA SOFTWARE)"
+
+archives:
+  - files:
+    - LICENSE
+    - README.md
+    - UPGRADING.md
+    - SECURITY.md
+    - CHANGELOG.md

.mergify.yml

@@ -1,10 +0,0 @@
-pull_request_rules:
-  - name: Automerge to master
-    conditions:
-      - base=master
-      - label=S:automerge
-    actions:
-      merge:
-        method: squash
-        strict: true
-        commit_message: title+body

.vscode/settings.json

@@ -1,8 +0,0 @@
-{
-  "protoc": {
-    "options": [
-      "--proto_path=${workspaceRoot}/proto",
-      "--proto_path=${workspaceRoot}/third_party/proto"
-    ]
-  }
-}

CHANGELOG.md

@@ -1,165 +1,14 @@
 # Changelog
 
-Friendly reminder, we have a [bug bounty program](https://hackerone.com/cosmos).
-
-## v0.34.20-rc1
-
-Special thanks to external contributors on this release: @joeabbey @yihuang
-
-### BUG FIXES
-
-- [indexer] [#8625](https://github.com/tendermint/tendermint/pull/8625) Fix overriding tx index of duplicated txs. (@yihuang)
-- [mempool] [\#8962](https://github.com/tendermint/tendermint/issues/8962) Backport priority mempool fixes from v0.35.x to v0.34.x (@creachadair).
-
-## v0.34.20-rc0
-
-This RC introduces the prioritized mempool.
-
-NOTE: There's a known memory leak with the prioritized mempool that the team are currently working on resolving. We will cut v0.34.20 when this has been resolved. This release candidate is to provide the SDK with the new APIs. Read more about the issue [here](https://github.com/tendermint/tendermint/issues/8775)
-
-### FEATURES
-
-- [cli] [\#8674] Add command to force compact goleveldb databases (@cmwaters)
-- [mempool] [\#8695] Port back the priority mempool. (@alexanderbez, @jmalicevic, @cmwaters)
-
-### IMPROVEMENTS
-
-- [logging] [\#8845](https://github.com/tendermint/tendermint/issues/8845) Add "Lazy" Stringers to defer Sprintf and Hash until logs print. (@joeabbey)
-
-### BUG FIXES
-
-- [blocksync] [\#8496](https://github.com/tendermint/tendermint/pull/8496) validate block against state before persisting it to disk (@cmwaters)
-
-## v0.34.19
-
-### BUG FIXES
-
-- [cli] [\#8270](https://github.com/tendermint/tendermint/issues/8270) fix reset commands (@alexanderbez).
-
-## v0.34.18
-
-### BREAKING CHANGES
-
-- CLI/RPC/Config
-    - [cli] [\#8258](https://github.com/tendermint/tendermint/pull/8258) Fix a bug in the cli that caused `unsafe-reset-all` to panic
-
-## v0.34.17
-
-### BREAKING CHANGES
-
-- CLI/RPC/Config
-
-   - [cli] [\#8081](https://github.com/tendermint/tendermint/issues/8081) make the reset command safe to use (@marbar3778).
-
-### BUG FIXES
-
-- [consensus] [\#8079](https://github.com/tendermint/tendermint/issues/8079) start the timeout ticker before relay (backport #7844) (@creachadair).
-- [consensus] [\#7992](https://github.com/tendermint/tendermint/issues/7992) [\#7994](https://github.com/tendermint/tendermint/issues/7994) change lock handling in handleMsg and reactor to alleviate issues gossiping during long ABCI calls (@williambanfield).
-
-## v0.34.16
-
-Special thanks to external contributors on this release: @yihuang
-
-### BUG FIXES
-
-- [consensus] [\#7617](https://github.com/tendermint/tendermint/issues/7617) calculate prevote message delay metric (backport #7551) (@williambanfield).
-- [consensus] [\#7631](https://github.com/tendermint/tendermint/issues/7631) check proposal non-nil in prevote message delay metric (backport #7625) (@williambanfield).
-- [statesync] [\#7885](https://github.com/tendermint/tendermint/issues/7885) statesync: assert app version matches (backport #7856) (@cmwaters).
-- [statesync] [\#7881](https://github.com/tendermint/tendermint/issues/7881) fix app hash in state rollback (backport #7837) (@cmwaters).
-- [cli] [#7837](https://github.com/tendermint/tendermint/pull/7837) fix app hash in state rollback. (@yihuang).
-
-## v0.34.15
-
-Special thanks to external contributors on this release: @thanethomson
-
-### BUG FIXES
-
-- [\#7368](https://github.com/tendermint/tendermint/issues/7368) cmd: add integration test for rollback functionality (@cmwaters).
-- [\#7309](https://github.com/tendermint/tendermint/issues/7309) pubsub: Report a non-nil error when shutting down (fixes #7306).
-- [\#7057](https://github.com/tendermint/tendermint/pull/7057) Import Postgres driver support for the psql indexer (@creachadair).
-- [\#7106](https://github.com/tendermint/tendermint/pull/7106) Revert mutex change to ABCI Clients (@tychoish).
-
-### IMPROVEMENTS
-
-- [config] [\#7230](https://github.com/tendermint/tendermint/issues/7230) rpc: Add experimental config params to allow for subscription buffer size control (@thanethomson).
-
-## v0.34.14
-
-This release backports the `rollback` feature to allow recovery in the event of an incorrect app hash.
-
-### FEATURES
-
-- [\#6982](https://github.com/tendermint/tendermint/pull/6982) The tendermint binary now has built-in suppport for running the end-to-end test application (with state sync support) (@cmwaters).
-- [cli] [#7033](https://github.com/tendermint/tendermint/pull/7033) Add a `rollback` command to rollback to the previous tendermint state. This may be useful in the event of non-determinstic app hash or when reverting an upgrade. @cmwaters
-
-### IMPROVEMENTS
-
-- [\#7103](https://github.com/tendermint/tendermint/pull/7104) Remove IAVL dependency (backport of #6550) (@cmwaters)
-
-### BUG FIXES
-
-- [\#7057](https://github.com/tendermint/tendermint/pull/7057) Import Postgres driver support for the psql indexer (@creachadair).
-- [ABCI] [\#7110](https://github.com/tendermint/tendermint/issues/7110) Revert "change client to use multi-reader mutexes (#6873)" (@tychoish).
-
-## v0.34.13
-
-This release backports improvements to state synchronization and ABCI
-performance under concurrent load, and the PostgreSQL event indexer.
-
-### IMPROVEMENTS
-
-- [statesync] [\#6881](https://github.com/tendermint/tendermint/issues/6881) improvements to stateprovider logic (@cmwaters)
-- [ABCI] [\#6873](https://github.com/tendermint/tendermint/issues/6873) change client to use multi-reader mutexes (@tychoish)
-- [indexing] [\#6906](https://github.com/tendermint/tendermint/issues/6906) enable the PostgreSQL indexer sink (@creachadair)
-
-## v0.34.12
-
-Special thanks to external contributors on this release: @JayT106.
-
-### FEATURES
-
-- [rpc] [\#6717](https://github.com/tendermint/tendermint/pull/6717) introduce
-  `/genesis_chunked` rpc endpoint for handling large genesis files by chunking them (@tychoish)
-
-### IMPROVEMENTS
-
-- [rpc] [\#6825](https://github.com/tendermint/tendermint/issues/6825) Remove egregious INFO log from `ABCI#Query` RPC. (@alexanderbez)
-
-### BUG FIXES
-
-- [light] [\#6685](https://github.com/tendermint/tendermint/pull/6685) fix bug
-  with incorrectly handling contexts that would occasionally freeze state sync. (@cmwaters)
-- [privval] [\#6748](https://github.com/tendermint/tendermint/issues/6748) Fix vote timestamp to prevent chain halt (@JayT106)
-
-## v0.34.11
-
-*June 18, 2021*
-
-This release improves the robustness of statesync; tweaking channel priorities and timeouts and
-adding two new parameters to the state sync config.
-
-### BREAKING CHANGES
-
-- Apps
-    - [Version] [\#6494](https://github.com/tendermint/tendermint/issues/6494) `TMCoreSemVer` is not required to be set as a ldflag any longer.
-
-### IMPROVEMENTS
-
-- [statesync] [\#6566](https://github.com/tendermint/tendermint/issues/6566) Allow state sync fetchers and request timeout to be configurable. (@alexanderbez)
-- [statesync] [\#6378](https://github.com/tendermint/tendermint/issues/6378) Retry requests for snapshots and add a minimum discovery time (5s) for new snapshots. (@tychoish)
-- [statesync] [\#6582](https://github.com/tendermint/tendermint/issues/6582) Increase chunk priority and add multiple retry chunk requests (@cmwaters)
-
-### BUG FIXES
-
-- [evidence] [\#6375](https://github.com/tendermint/tendermint/issues/6375) Fix bug with inconsistent LightClientAttackEvidence hashing (@cmwaters)
-
 ## v0.34.10
 
 *April 14, 2021*
 
-This release fixes a bug where peers would sometimes try to send messages
+This release fixes a bug where peers would sometimes try to send messages 
 on incorrect channels. Special thanks to our friends at Oasis Labs for surfacing
-this issue!
+this issue! 
+
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
 
 - [p2p/node] [\#6339](https://github.com/tendermint/tendermint/issues/6339) Fix bug with using custom channels (@cmwaters)
 - [light] [\#6346](https://github.com/tendermint/tendermint/issues/6346) Correctly handle too high errors to improve client robustness (@cmwaters)
@@ -168,7 +17,7 @@ this issue!
 
 *April 8, 2021*
 
-This release fixes a moderate severity security issue, Security Advisory Alderfly,
+This release fixes a moderate severity security issue, Security Advisory Alderfly, 
 which impacts all networks that rely on Tendermint light clients.
 Further details will be released once networks have upgraded.
 
@@ -176,6 +25,8 @@ This release also includes a small Go API-breaking change, to reduce panics in t
 
 Special thanks to our external contributors on this release: @gchaincl
 
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES
 
 - Go API
@@ -198,6 +49,8 @@ Special thanks to our external contributors on this release: @gchaincl
 This release, in conjunction with [a fix in the Cosmos SDK](https://github.com/cosmos/cosmos-sdk/pull/8641),
 introduces changes that should mean the logs are much, much quieter. 🎉
 
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### IMPROVEMENTS
 
 - [libs/log] [\#6174](https://github.com/tendermint/tendermint/issues/6174) Include timestamp (`ts` field; `time.RFC3339Nano` format) in JSON logger output (@melekes)
@@ -235,44 +88,49 @@ use remote signer implementations instead of `FilePV` in production.
 Thank you to @joe-bowman for his assistance with this vulnerability and a particular
 shout-out to @marbar3778 for diagnosing it quickly.
 
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BUG FIXES
 
 - [consensus] [\#6128](https://github.com/tendermint/tendermint/pull/6128) Remove privValidator from log call (@tessr)
 
 ## v0.34.6
 
-*February 18, 2021*
+*February 18, 2021* 
 
-_Tendermint Core v0.34.5 and v0.34.6 have been recalled due to build tooling problems._
+_Tendermint Core v0.34.5 and v0.34.6 have been recalled due to release tooling problems._
 
 ## v0.34.4
 
 *February 11, 2021*
 
-This release includes a fix for a memory leak in the evidence reactor (see #6068, below).
-All Tendermint clients are recommended to upgrade.
-Thank you to our friends at Crypto.com for the initial report of this memory leak!
+This release includes a fix for a memory leak in the evidence reactor (see #6068, below). 
+All Tendermint clients are recommended to upgrade. 
+Thank you to our friends at Crypto.com for the initial report of this memory leak! 
 
 Special thanks to other external contributors on this release: @yayajacky, @odidev, @laniehei, and @c29r3!
 
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BUG FIXES
 
 - [light] [\#6022](https://github.com/tendermint/tendermint/pull/6022) Fix a bug when the number of validators equals 100 (@melekes)
 - [light] [\#6026](https://github.com/tendermint/tendermint/pull/6026) Fix a bug when height isn't provided for the rpc calls: `/commit` and `/validators` (@cmwaters)
 - [evidence] [\#6068](https://github.com/tendermint/tendermint/pull/6068) Terminate broadcastEvidenceRoutine when peer is stopped (@melekes)
 
-
-## v0.34.3
+## v0.34.3 
 
 *January 19, 2021*
 
-This release includes a fix for a high-severity security vulnerability,
+This release includes a fix for a high-severity security vulnerability, 
 a DoS-vector that impacted Tendermint Core v0.34.0-v0.34.2. For more details, see
-[Security Advisory Mulberry](https://github.com/tendermint/tendermint/security/advisories/GHSA-p658-8693-mhvg)
-or https://nvd.nist.gov/vuln/detail/CVE-2021-21271.
+[Security Advisory Mulberry](https://github.com/tendermint/tendermint/security/advisories/GHSA-p658-8693-mhvg) 
+or https://nvd.nist.gov/vuln/detail/CVE-2021-21271. 
 
 Tendermint Core v0.34.3 also updates GoGo Protobuf to 1.3.2 in order to pick up the fix for
-https://nvd.nist.gov/vuln/detail/CVE-2021-3121.
+https://nvd.nist.gov/vuln/detail/CVE-2021-3121. 
+
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
 
 ### BUG FIXES
 
@@ -287,6 +145,8 @@ This release fixes a substantial bug in evidence handling where evidence could
 sometimes be broadcast before the block containing that evidence was fully committed,
 resulting in some nodes panicking when trying to verify said evidence.
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES
 
 - Go API
@@ -310,6 +170,8 @@ disconnecting from this node. As a temporary remedy (until the mempool package
 is refactored), the `max-batch-bytes` was disabled. Transactions will be sent
 one by one without batching.
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES
 
 - CLI/RPC/Config
@@ -338,6 +200,8 @@ Holy smokes, this is a big one! For a more reader-friendly overview of the chang
 Special thanks to external contributors on this release: @james-ray, @fedekunze, @favadi, @alessio,
 @joe-bowman, @cuonglm, @SadPencil and @dongsam.
 
+And as always, friendly reminder, that we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES
 
 - CLI/RPC/Config
@@ -364,14 +228,14 @@ Special thanks to external contributors on this release: @james-ray, @fedekunze,
   - [blockchain] [\#4637](https://github.com/tendermint/tendermint/pull/4637) Migrate blockchain reactor(s) to Protobuf encoding (@marbar3778)
   - [evidence] [\#4949](https://github.com/tendermint/tendermint/pull/4949) Migrate evidence reactor to Protobuf encoding (@marbar3778)
   - [mempool] [\#4940](https://github.com/tendermint/tendermint/pull/4940) Migrate mempool from to Protobuf encoding (@marbar3778)
-  - [mempool] [\#5321](https://github.com/tendermint/tendermint/pull/5321) Batch transactions when broadcasting them to peers (@melekes)
+  - [mempool] [\#5321](https://github.com/tendermint/tendermint/pull/5321) Batch transactions when broadcasting them to peers (@melekes) 
      - `MaxBatchBytes` new config setting defines the max size of one batch.
   - [p2p/pex] [\#4973](https://github.com/tendermint/tendermint/pull/4973) Migrate `p2p/pex` reactor to Protobuf encoding (@marbar3778)
   - [statesync] [\#4943](https://github.com/tendermint/tendermint/pull/4943) Migrate state sync reactor to Protobuf encoding (@marbar3778)
 
 - Blockchain Protocol
 
-  - [evidence] [\#4725](https://github.com/tendermint/tendermint/pull/4725) Remove `Pubkey` from `DuplicateVoteEvidence` (@marbar3778)
+  - [evidence] [\#4725](https://github.com/tendermint/tendermint/pull/4725) Remove `Pubkey` from `DuplicateVoteEvidence` (@marbar3778) 
   - [evidence] [\#5499](https://github.com/tendermint/tendermint/pull/5449) Cap evidence to a maximum number of bytes (supercedes [\#4780](https://github.com/tendermint/tendermint/pull/4780)) (@cmwaters)
   - [merkle] [\#5193](https://github.com/tendermint/tendermint/pull/5193) Header hashes are no longer empty for empty inputs, notably `DataHash`, `EvidenceHash`, and `LastResultsHash` (@erikgrinaker)
   - [state] [\#4845](https://github.com/tendermint/tendermint/pull/4845) Include `GasWanted` and `GasUsed` into `LastResultsHash` (@melekes)
@@ -430,7 +294,7 @@ Special thanks to external contributors on this release: @james-ray, @fedekunze,
   - [types] [\#4852](https://github.com/tendermint/tendermint/pull/4852) Vote & Proposal `SignBytes` is now func `VoteSignBytes` & `ProposalSignBytes` (@marbar3778)
   - [types] [\#4798](https://github.com/tendermint/tendermint/pull/4798) Simplify `VerifyCommitTrusting` func + remove extra validation (@melekes)
   - [types] [\#4845](https://github.com/tendermint/tendermint/pull/4845) Remove `ABCIResult` (@melekes)
-  - [types] [\#5029](https://github.com/tendermint/tendermint/pull/5029) Rename all values from `PartsHeader` to `PartSetHeader` to have consistency (@marbar3778)
+  - [types] [\#5029](https://github.com/tendermint/tendermint/pull/5029) Rename all values from `PartsHeader` to `PartSetHeader` to have consistency (@marbar3778) 
   - [types] [\#4939](https://github.com/tendermint/tendermint/pull/4939) `Total` in `Parts` & `PartSetHeader` has been changed from a `int` to a `uint32` (@marbar3778)
   - [types] [\#4939](https://github.com/tendermint/tendermint/pull/4939) Vote: `ValidatorIndex` & `Round` are now `int32` (@marbar3778)
   - [types] [\#4939](https://github.com/tendermint/tendermint/pull/4939) Proposal: `POLRound` & `Round` are now `int32` (@marbar3778)
@@ -468,7 +332,7 @@ Special thanks to external contributors on this release: @james-ray, @fedekunze,
 - [evidence] [\#4722](https://github.com/tendermint/tendermint/pull/4722) Consolidate evidence store and pool types to improve evidence DB (@cmwaters)
 - [evidence] [\#4839](https://github.com/tendermint/tendermint/pull/4839) Reject duplicate evidence from being proposed (@cmwaters)
 - [evidence] [\#5219](https://github.com/tendermint/tendermint/pull/5219) Change the source of evidence time to block time (@cmwaters)
-- [libs] [\#5126](https://github.com/tendermint/tendermint/pull/5126) Add a sync package which wraps sync.(RW)Mutex & deadlock.(RW)Mutex and use a build flag (deadlock) in order to enable deadlock checking (@marbar3778)
+- [libs] [\#5126](https://github.com/tendermint/tendermint/pull/5126) Add a sync package which wraps sync.(RW)Mutex & deadlock.(RW)Mutex and use a build flag (deadlock) in order to enable deadlock checking (@marbar3778) 
 - [light] [\#4935](https://github.com/tendermint/tendermint/pull/4935) Fetch and compare a new header with witnesses in parallel (@melekes)
 - [light] [\#4929](https://github.com/tendermint/tendermint/pull/4929) Compare header with witnesses only when doing bisection (@melekes)
 - [light] [\#4916](https://github.com/tendermint/tendermint/pull/4916) Validate basic for inbound validator sets and headers before further processing them (@cmwaters)
@@ -578,6 +442,9 @@ as 2/3+ of the signatures are checked._
 
 Special thanks to @njmurarka at Bluzelle Networks for reporting this.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [consensus] Do not allow signatures for a wrong block in commits (@ebuchman)
@@ -593,6 +460,8 @@ need to update your code.**
 
 Special thanks to external contributors on this release: @tau3,
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - Go API
@@ -652,6 +521,8 @@ Special thanks to external contributors on this release: @tau3,
 
 Special thanks to external contributors on this release: @whylee259, @greg-szabo
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - Go API
@@ -738,6 +609,9 @@ Notes:
 Special thanks to [fudongbai](https://hackerone.com/fudongbai) for finding
 and reporting this.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [mempool] Reserve IDs in InitPeer instead of AddPeer (@tessr)
@@ -750,6 +624,8 @@ and reporting this.
 Special thanks to external contributors on this release:
 @antho1404, @michaelfig, @gterzian, @tau3, @Shivani912
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - CLI/RPC/Config
@@ -800,6 +676,9 @@ Special thanks to external contributors on this release:
 Special thanks to external contributors on this release:
 @princesinha19
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### FEATURES:
 
 - [rpc] [\#3333](https://github.com/tendermint/tendermint/issues/3333) Add `order_by` to `/tx_search` endpoint, allowing to change default ordering from asc to desc (@princesinha19)
@@ -818,6 +697,9 @@ Special thanks to external contributors on this release:
 
 Special thanks to external contributors on this release: @mrekucci, @PSalant726, @princesinha19, @greg-szabo, @dongsam, @cuonglm, @jgimeno, @yenkhoon
 
+Friendly reminder, we have a [bug bounty
+program.](https://hackerone.com/tendermint).
+
 *January 14, 2020*
 
 This release contains breaking changes to the `Block#Header`, specifically
@@ -1046,6 +928,9 @@ Notes:
 Special thanks to [fudongbai](https://hackerone.com/fudongbai) for finding
 and reporting this.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [mempool] Reserve IDs in InitPeer instead of AddPeer (@tessr)
@@ -1057,6 +942,9 @@ _January, 9, 2020_
 
 Special thanks to external contributors on this release: @greg-szabo, @gregzaitsev, @yenkhoon
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### FEATURES:
 
 - [rpc/lib] [\#4248](https://github.com/tendermint/tendermint/issues/4248) RPC client basic authentication support (@greg-szabo)
@@ -1078,6 +966,9 @@ Special thanks to external contributors on this release: @greg-szabo, @gregzaits
 
 Special thanks to external contributors on this release: @erikgrinaker, @guagualvcha, @hsyis, @cosmostuba, @whunmr, @austinabell
 
+Friendly reminder, we have a [bug bounty
+program.](https://hackerone.com/tendermint).
+
 
 ### BREAKING CHANGES:
 
@@ -1117,6 +1008,9 @@ identified and fixed here.
 Special thanks to [elvishacker](https://hackerone.com/elvishacker) for finding
 and reporting this.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - Go API
@@ -1143,6 +1037,9 @@ accepting new peers and only allowing `ed25519` pubkeys.
 Special thanks to [fudongbai](https://hackerone.com/fudongbai) for pointing
 this out.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [p2p] [\#4030](https://github.com/tendermint/tendermint/issues/4030) Only allow ed25519 pubkeys when connecting
@@ -1158,6 +1055,9 @@ All clients are recommended to upgrade. See
 Special thanks to [fudongbai](https://hackerone.com/fudongbai) for discovering
 and reporting this issue.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [p2p] [\#4030](https://github.com/tendermint/tendermint/issues/4030) Fix for panic on nil public key send to a peer
@@ -1168,6 +1068,9 @@ and reporting this issue.
 
 Special thanks to external contributors on this release: @jon-certik, @gracenoah, @PSalant726, @gchaincl
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - CLI/RPC/Config
@@ -1203,6 +1106,9 @@ guide.
 Special thanks to external contributors on this release:
 @gchaincl, @bluele, @climber73
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### IMPROVEMENTS:
 
 - [consensus] [\#3839](https://github.com/tendermint/tendermint/issues/3839) Reduce "Error attempting to add vote" message severity (Error -> Info)
@@ -1223,6 +1129,9 @@ Special thanks to external contributors on this release:
 Special thanks to external contributors on this release:
 @ruseinov, @bluele, @guagualvcha
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - Go API
@@ -1262,6 +1171,9 @@ This release contains a minor enhancement to the ABCI and some breaking changes
 - CheckTx requests include a `CheckTxType` enum that can be set to `Recheck` to indicate to the application that this transaction was already checked/validated and certain expensive operations (like checking signatures) can be skipped
 - Removed various functions from `libs` pkgs
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - Go API
@@ -1307,6 +1219,9 @@ and the RPC, namely:
   [docs](https://github.com/tendermint/tendermint/blob/60827f75623b92eff132dc0eff5b49d2025c591e/docs/spec/abci/abci.md#events)
 - Bind RPC to localhost by default, not to the public interface [UPGRADING/RPC_Changes](./UPGRADING.md#rpc_changes)
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 * CLI/RPC/Config
@@ -1407,6 +1322,9 @@ Notes:
 Special thanks to [fudongbai](https://hackerone.com/fudongbai) for finding
 and reporting this.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [mempool] Reserve IDs in InitPeer instead of AddPeer (@tessr)
@@ -1426,6 +1344,9 @@ identified and fixed here.
 Special thanks to [elvishacker](https://hackerone.com/elvishacker) for finding
 and reporting this.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 - Go API
@@ -1452,6 +1373,9 @@ accepting new peers and only allowing `ed25519` pubkeys.
 Special thanks to [fudongbai](https://hackerone.com/fudongbai) for pointing
 this out.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [p2p] [\#4030](https://github.com/tendermint/tendermint/issues/4030) Only allow ed25519 pubkeys when connecting
@@ -1467,6 +1391,9 @@ All clients are recommended to upgrade. See
 Special thanks to [fudongbai](https://hackerone.com/fudongbai) for discovering
 and reporting this issue.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### SECURITY:
 
 - [p2p] [\#4030](https://github.com/tendermint/tendermint/issues/4030) Fix for panic on nil public key send to a peer
@@ -1761,6 +1688,9 @@ See the [v0.31.0
 Milestone](https://github.com/tendermint/tendermint/milestone/19?closed=1) for
 more details.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 * CLI/RPC/Config
@@ -1771,7 +1701,7 @@ more details.
   - [rpc] [\#3269](https://github.com/tendermint/tendermint/issues/2826) Limit number of unique clientIDs with open subscriptions. Configurable via `rpc.max_subscription_clients`
   - [rpc] [\#3269](https://github.com/tendermint/tendermint/issues/2826) Limit number of unique queries a given client can subscribe to at once. Configurable via `rpc.max_subscriptions_per_client`.
   - [rpc] [\#3435](https://github.com/tendermint/tendermint/issues/3435) Default ReadTimeout and WriteTimeout changed to 10s. WriteTimeout can increased by setting `rpc.timeout_broadcast_tx_commit` in the config.
-  - [rpc/client] [\#3269](https://github.com/tendermint/tendermint/issues/3269) Update `EventsClient` interface to reflect new pubsub/eventBus API [ADR-33](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-033-pubsub.md). This includes `Subscribe`, `Unsubscribe`, and `UnsubscribeAll` methods.
+  - [rpc/client] [\#3269](https://github.com/tendermint/tendermint/issues/3269) Update `EventsClient` interface to reflect new pubsub/eventBus API [ADR-33](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-033-pubsub.md). This includes `Subscribe`, `Unsubscribe`, and `UnsubscribeAll` methods.
 
 * Apps
   - [abci] [\#3403](https://github.com/tendermint/tendermint/issues/3403) Remove `time_iota_ms` from BlockParams. This is a
@@ -1824,7 +1754,7 @@ more details.
 - [blockchain] [\#3358](https://github.com/tendermint/tendermint/pull/3358) Fix timer leak in `BlockPool` (@guagualvcha)
 - [cmd] [\#3408](https://github.com/tendermint/tendermint/issues/3408) Fix `testnet` command's panic when creating non-validator configs (using `--n` flag) (@srmo)
 - [libs/db/remotedb/grpcdb] [\#3402](https://github.com/tendermint/tendermint/issues/3402) Close Iterator/ReverseIterator after use
-- [libs/pubsub] [\#951](https://github.com/tendermint/tendermint/issues/951), [\#1880](https://github.com/tendermint/tendermint/issues/1880) Use non-blocking send when dispatching messages [ADR-33](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-033-pubsub.md)
+- [libs/pubsub] [\#951](https://github.com/tendermint/tendermint/issues/951), [\#1880](https://github.com/tendermint/tendermint/issues/1880) Use non-blocking send when dispatching messages [ADR-33](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-033-pubsub.md)
 - [lite] [\#3364](https://github.com/tendermint/tendermint/issues/3364) Fix `/validators` and `/abci_query` proxy endpoints
   (@guagualvcha)
 - [p2p/conn] [\#3347](https://github.com/tendermint/tendermint/issues/3347) Reject all-zero shared secrets in the Diffie-Hellman step of secret-connection
@@ -1891,7 +1821,7 @@ For more, see issues marked
 
 This release also includes a fix to prevent Tendermint from including the same
 piece of evidence in more than one block. This issue was reported by @chengwenxi in our
-[bug bounty program](https://hackerone.com/cosmos).
+[bug bounty program](https://hackerone.com/tendermint).
 
 ### BREAKING CHANGES:
 
@@ -1980,6 +1910,9 @@ This release contains two important fixes: one for p2p layer where we sometimes
 were not closing connections and one for consensus layer where consensus with
 no empty blocks (`create_empty_blocks = false`) could halt.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### IMPROVEMENTS:
 - [pex] [\#3037](https://github.com/tendermint/tendermint/issues/3037) Only log "Reached max attempts to dial" once
 - [rpc] [\#3159](https://github.com/tendermint/tendermint/issues/3159) Expose
@@ -2018,6 +1951,9 @@ While we are trying to stabilize the Block protocol to preserve compatibility
 with old chains, there may be some final changes yet to come before Cosmos
 launch as we continue to audit and test the software.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 * CLI/RPC/Config
@@ -2065,6 +2001,9 @@ launch as we continue to audit and test the software.
 Special thanks to external contributors on this release:
 @HaoyangLiu
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BUG FIXES:
 - [consensus] Fix consensus halt from proposing blocks with too much evidence
 
@@ -2117,7 +2056,7 @@ See [UPGRADING.md](UPGRADING.md) for more details.
 
 - [build] [\#3085](https://github.com/tendermint/tendermint/issues/3085) Fix `Version` field in build scripts (@husio)
 - [crypto/multisig] [\#3102](https://github.com/tendermint/tendermint/issues/3102) Fix multisig keys address length
-- [crypto/encoding] [\#3101](https://github.com/tendermint/tendermint/issues/3101) Fix `PubKeyMultisigThreshold` unmarshalling into `crypto.PubKey` interface
+- [crypto/encoding] [\#3101](https://github.com/tendermint/tendermint/issues/3101) Fix `PubKeyMultisigThreshold` unmarshaling into `crypto.PubKey` interface
 - [p2p/conn] [\#3111](https://github.com/tendermint/tendermint/issues/3111) Make SecretConnection thread safe
 - [rpc] [\#3053](https://github.com/tendermint/tendermint/issues/3053) Fix internal error in `/tx_search` when results are empty
   (@gianfelipe93)
@@ -2192,6 +2131,9 @@ Special thanks to @dlguddus for discovering a [major
 issue](https://github.com/tendermint/tendermint/issues/2718#issuecomment-440888677)
 in the proposer selection algorithm.
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 This release is primarily about fixes to the proposer selection algorithm
 in preparation for the [Cosmos Game of
 Stakes](https://blog.cosmos.network/the-game-of-stakes-is-open-for-registration-83a404746ee6).
@@ -2253,6 +2195,9 @@ Special thanks to external contributors on this release:
 @ackratos, @goolAdapter, @james-ray, @joe-bowman, @kostko,
 @nagarajmanjunath, @tomtau
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### FEATURES:
 
 - [rpc] [\#2747](https://github.com/tendermint/tendermint/issues/2747) Enable subscription to tags emitted from `BeginBlock`/`EndBlock` (@kostko)
@@ -2291,6 +2236,9 @@ Special thanks to external contributors on this release:
 Special thanks to external contributors on this release:
 @danil-lashin, @kevlubkcm, @krhubert, @srmo
 
+Friendly reminder, we have a [bug bounty
+program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES:
 
 * Go API
@@ -2334,6 +2282,8 @@ Special thanks to external contributors on this release:
 
 Special thanks to external contributors on this release: @hleb-albau, @zhuzeyu
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### FEATURES:
 
 - [rpc] [\#2582](https://github.com/tendermint/tendermint/issues/2582) Enable CORS on RPC API (@hleb-albau)
@@ -2351,6 +2301,8 @@ Special thanks to external contributors on this release: @hleb-albau, @zhuzeyu
 
 Special thanks to external contributors on this release: @katakonst
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### IMPROVEMENTS:
 
 - [consensus] [\#2704](https://github.com/tendermint/tendermint/issues/2704) Simplify valid POL round logic
@@ -2378,7 +2330,7 @@ Special thanks to external contributors on this release:
 @james-ray, @overbool, @phymbert, @Slamper, @Uzair1995, @yutianwu.
 
 Special thanks to @Slamper for a series of bug reports in our [bug bounty
-program](https://hackerone.com/cosmos) which are fixed in this release.
+program](https://hackerone.com/tendermint) which are fixed in this release.
 
 This release is primarily about adding Version fields to various data structures,
 optimizing consensus messages for signing and verification in
@@ -2522,7 +2474,9 @@ Special thanks to external contributors on this release:
 This release is mostly about the ConsensusParams - removing fields and enforcing MaxGas.
 It also addresses some issues found via security audit, removes various unused
 functions from `libs/common`, and implements
-[ADR-012](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-012-peer-transport.md).
+[ADR-012](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-012-peer-transport.md).
+
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
 
 BREAKING CHANGES:
 
@@ -2553,7 +2507,7 @@ FEATURES:
 - [libs] [\#2286](https://github.com/tendermint/tendermint/issues/2286) Panic if `autofile` or `db/fsdb` permissions change from 0600.
 
 IMPROVEMENTS:
-- [libs/db] [\#2371](https://github.com/tendermint/tendermint/issues/2371) Output error instead of panic when the given `db_backend` is not initialised (@bradyjoestar)
+- [libs/db] [\#2371](https://github.com/tendermint/tendermint/issues/2371) Output error instead of panic when the given `db_backend` is not initialized (@bradyjoestar)
 - [mempool] [\#2399](https://github.com/tendermint/tendermint/issues/2399) Make mempool cache a proper LRU (@bradyjoestar)
 - [p2p] [\#2126](https://github.com/tendermint/tendermint/issues/2126) Introduce PeerTransport interface to improve isolation of concerns
 - [libs/common] [\#2326](https://github.com/tendermint/tendermint/issues/2326) Service returns ErrNotStarted
@@ -2603,7 +2557,7 @@ BREAKING CHANGES:
   - [abci] Added address of the original proposer of the block to Header
   - [abci] Change ABCI Header to match Tendermint exactly
   - [abci] [\#2159](https://github.com/tendermint/tendermint/issues/2159) Update use of `Validator` (see
-    [ADR-018](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-018-ABCI-Validators.md)):
+    [ADR-018](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-018-ABCI-Validators.md)):
     - Remove PubKey from `Validator` (so it's just Address and Power)
     - Introduce `ValidatorUpdate` (with just PubKey and Power)
     - InitChain and EndBlock use ValidatorUpdate
@@ -2625,7 +2579,7 @@ BREAKING CHANGES:
   - [state] [\#1815](https://github.com/tendermint/tendermint/issues/1815) Validator set changes are now delayed by one block (!)
     - Add NextValidatorSet to State, changes on-disk representation of state
   - [state] [\#2184](https://github.com/tendermint/tendermint/issues/2184) Enforce ConsensusParams.BlockSize.MaxBytes (See
-    [ADR-020](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-020-block-size.md)).
+    [ADR-020](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-020-block-size.md)).
     - Remove ConsensusParams.BlockSize.MaxTxs
     - Introduce maximum sizes for all components of a block, including ChainID
   - [types] Updates to the block Header:
@@ -2636,7 +2590,7 @@ BREAKING CHANGES:
   - [consensus] [\#2203](https://github.com/tendermint/tendermint/issues/2203) Implement BFT time
     - Timestamp in block must be monotonic and equal the median of timestamps in block's LastCommit
   - [crypto] [\#2239](https://github.com/tendermint/tendermint/issues/2239) Secp256k1 signature changes (See
-    [ADR-014](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-014-secp-malleability.md)):
+    [ADR-014](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-014-secp-malleability.md)):
     - format changed from DER to `r || s`, both little endian encoded as 32 bytes.
     - malleability removed by requiring `s` to be in canonical form.
 

CHANGELOG_PENDING.md

@@ -1,25 +1,104 @@
 # Unreleased Changes
 
-## v0.34.20
+## vX.X
 
 Special thanks to external contributors on this release:
 
-Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
 
 ### BREAKING CHANGES
 
 - CLI/RPC/Config
+  - [config] \#5598 The `test_fuzz` and `test_fuzz_config` P2P settings have been removed. (@erikgrinaker)
+  - [config] \#5728 `fast_sync = "v1"` is no longer supported (@melekes)
+  - [cli] \#5772 `gen_node_key` prints JSON-encoded `NodeKey` rather than ID and does not save it to `node_key.json` (@melekes)
+  - [cli] \#5777 use hyphen-case instead of snake_case for all cli commands and config parameters (@cmwaters)
+  - [rpc] \#6019 standardise RPC errors and return the correct status code (@bipulprasad & @cmwaters)
+  - [rpc] \#6168 Change default sorting to desc for `/tx_search` results (@melekes)
+  - [cli] \#6282 User must specify the node mode when using `tendermint init` (@cmwaters)
+  - [state/indexer] \#6382 reconstruct indexer, move txindex into the indexer package (@JayT106)
+  - [cli] \#6372 Introduce `BootstrapPeers` as part of the new p2p stack. Peers to be connected on
+    startup (@cmwaters)
 
 - Apps
+  - [ABCI] \#6408 Change the `key` and `value` fields from `[]byte` to `string` in the `EventAttribute` type. (@alexanderbez)
+  - [ABCI] \#5447 Remove `SetOption` method from `ABCI.Client` interface
+  - [ABCI] \#5447 Reset `Oneof` indexes for  `Request` and `Response`.
+  - [ABCI] \#5818 Use protoio for msg length delimitation. Migrates from int64 to uint64 length delimiters.
 
 - P2P Protocol
 
 - Go API
+  - [abci/client, proxy] \#5673 `Async` funcs return an error, `Sync` and `Async` funcs accept `context.Context` (@melekes)
+  - [p2p] Removed unused function `MakePoWTarget`. (@erikgrinaker)
+  - [libs/bits] \#5720 Validate `BitArray` in `FromProto`, which now returns an error (@melekes)
+  - [proto/p2p] Renamed `DefaultNodeInfo` and `DefaultNodeInfoOther` to `NodeInfo` and `NodeInfoOther` (@erikgrinaker)
+  - [proto/p2p] Rename `NodeInfo.default_node_id` to `node_id` (@erikgrinaker)
+  - [libs/os] Kill() and {Must,}{Read,Write}File() functions have been removed. (@alessio)
+  - [store] \#5848 Remove block store state in favor of using the db iterators directly (@cmwaters)
+  - [state] \#5864 Use an iterator when pruning state (@cmwaters)
+  - [types] \#6023 Remove `tm2pb.Header`, `tm2pb.BlockID`, `tm2pb.PartSetHeader` and `tm2pb.NewValidatorUpdate`.
+	- Each of the above types has a `ToProto` and `FromProto` method or function which replaced this logic.
+  - [light] \#6054 Move `MaxRetryAttempt` option from client to provider.
+	- `NewWithOptions` now sets the max retry attempts and timeouts (@cmwaters)
+  - [all] \#6077 Change spelling from British English to American (@cmwaters)
+	- Rename "Subscription.Cancelled()" to "Subscription.Canceled()" in libs/pubsub
+	- Rename "behaviour" pkg to "behavior" and internalized it in blockchain v2
+  - [rpc/client/http] \#6176 Remove `endpoint` arg from `New`, `NewWithTimeout` and `NewWithClient` (@melekes)
+  - [rpc/client/http] \#6176 Unexpose `WSEvents` (@melekes)
+  - [rpc/jsonrpc/client/ws_client] \#6176 `NewWS` no longer accepts options (use `NewWSWithOptions` and `OnReconnect` funcs to configure the client) (@melekes)
+  - [libs/rand] \#6364 Removed most of libs/rand in favour of standard lib's `math/rand` (@liamsi)
 
 - Blockchain Protocol
 
+- Data Storage
+  - [store/state/evidence/light] \#5771 Use an order-preserving varint key encoding (@cmwaters)
+  - [mempool] \#6396 Remove mempool's write ahead log (WAL), (previously unused by the tendermint code). (@tychoish)
+
 ### FEATURES
 
+- [config] Add `--mode` flag and config variable. See [ADR-52](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-052-tendermint-mode.md) @dongsam
+- [rpc] \#6329 Don't cap page size in unsafe mode (@gotjoshua, @cmwaters)
+- [pex] \#6305 v2 pex reactor with backwards compatability. Introduces two new pex messages to
+  accomodate for the new p2p stack. Removes the notion of seeds and crawling. All peer
+  exchange reactors behave the same. (@cmwaters)
+- [crypto] \#6376 Enable sr25519 as a validator key
+
 ### IMPROVEMENTS
 
+- [crypto/ed25519] \#5632 Adopt zip215 `ed25519` verification. (@marbar3778)
+- [privval] \#5603 Add `--key` to `init`, `gen_validator`, `testnet` & `unsafe_reset_priv_validator` for use in generating `secp256k1` keys.
+- [privval] \#5725 Add gRPC support to private validator.
+- [privval] \#5876 `tendermint show-validator` will query the remote signer if gRPC is being used (@marbar3778)
+- [abci/client] \#5673 `Async` requests return an error if queue is full (@melekes)
+- [mempool] \#5673 Cancel `CheckTx` requests if RPC client disconnects or times out (@melekes)
+- [abci] \#5706 Added `AbciVersion` to `RequestInfo` allowing applications to check ABCI version when connecting to Tendermint. (@marbar3778)
+- [blockchain/v1] \#5728 Remove in favor of v2 (@melekes)
+- [blockchain/v0] \#5741 Relax termination conditions and increase sync timeout (@melekes)
+- [cli] \#5772 `gen_node_key` output now contains node ID (`id` field) (@melekes)
+- [blockchain/v2] \#5774 Send status request when new peer joins (@melekes)
+- [consensus] \#5792 Deprecates the `time_iota_ms` consensus parameter, to reduce the bug surface. The parameter is no longer used. (@valardragon)
+- [store] \#5888 store.SaveBlock saves using batches instead of transactions for now to improve ACID properties. This is a quick fix for underlying issues around tm-db and ACID guarantees. (@githubsands)
+- [consensus] \#5987 Remove `time_iota_ms` from consensus params. Merge `tmproto.ConsensusParams` and `abci.ConsensusParams`. (@marbar3778)
+- [types] \#5994 Reduce the use of protobuf types in core logic. (@marbar3778)
+  - `ConsensusParams`, `BlockParams`, `ValidatorParams`, `EvidenceParams`, `VersionParams`, `sm.Version` and `version.Consensus` have become native types. They still utilize protobuf when being sent over the wire or written to disk.
+- [rpc/client/http] \#6163 Do not drop events even if the `out` channel is full (@melekes)
+- [node] \#6059 Validate and complete genesis doc before saving to state store (@silasdavis)
+- [state] \#6067 Batch save state data (@githubsands & @cmwaters)
+- [crypto] \#6120 Implement batch verification interface for ed25519 and sr25519. (@marbar3778)
+- [types] \#6120 use batch verification for verifying commits signatures.
+  - If the key type supports the batch verification API it will try to batch verify. If the verification fails we will single verify each signature.
+- [privval/file] \#6185 Return error on `LoadFilePV`, `LoadFilePVEmptyState`. Allows for better programmatic control of Tendermint.
+- [privval] \#6240 Add `context.Context` to privval interface.
+- [rpc] \#6265 set cache control in http-rpc response header (@JayT106)
+- [statesync] \#6378 Retry requests for snapshots and add a minimum discovery time (5s) for new snapshots.
+- [node/state] \#6370 graceful shutdown in the consensus reactor (@JayT106)
+- [crypto/merkle] \#6443 Improve HashAlternatives performance (@cuonglm)
+
 ### BUG FIXES
+
+- [types] \#5523 Change json naming of `PartSetHeader` within `BlockID` from `parts` to `part_set_header` (@marbar3778)
+- [privval] \#5638 Increase read/write timeout to 5s and calculate ping interval based on it (@JoeKash)
+- [blockchain/v1] [\#5701](https://github.com/tendermint/tendermint/pull/5701) Handle peers without blocks (@melekes)
+- [blockchain/v1] \#5711 Fix deadlock (@melekes)
+- [evidence] \#6375 Fix bug with inconsistent LightClientAttackEvidence hashing (cmwaters)

CONTRIBUTING.md

@@ -26,7 +26,8 @@ will indicate their support with a heartfelt emoji.
 
 If the issue would benefit from thorough discussion, maintainers may
 request that you create a [Request For
-Comment](https://github.com/tendermint/spec/tree/master/rfc). Discussion
+Comment](https://github.com/tendermint/spec/tree/master/rfc)
+in the Tendermint spec repo. Discussion
 at the RFC stage will build collective understanding of the dimensions
 of the problems and help structure conversations around trade-offs.
 
@@ -106,22 +107,23 @@ specify exactly the dependency you want to update, eg.
 
 We use [Protocol Buffers](https://developers.google.com/protocol-buffers) along with [gogoproto](https://github.com/gogo/protobuf) to generate code for use across Tendermint Core.
 
-For linting and checking breaking changes, we use [buf](https://buf.build/). If you would like to run linting and check if the changes you have made are breaking then you will need to have docker running locally. Then the linting cmd will be `make proto-lint` and the breaking changes check will be `make proto-check-breaking`.
+For linting, checking breaking changes and generating proto stubs, we use [buf](https://buf.build/). If you would like to run linting and check if the changes you have made are breaking then you will need to have docker running locally. Then the linting cmd will be `make proto-lint` and the breaking changes check will be `make proto-check-breaking`.
 
 We use [Docker](https://www.docker.com/) to generate the protobuf stubs. To generate the stubs yourself, make sure docker is running then run `make proto-gen`.
 
-## Vagrant
+### Visual Studio Code
 
-If you are a [Vagrant](https://www.vagrantup.com/) user, you can get started
-hacking Tendermint with the commands below.
+If you are a VS Code user, you may want to add the following to your `.vscode/settings.json`:
 
-NOTE: In case you installed Vagrant in 2017, you might need to run
-`vagrant box update` to upgrade to the latest `ubuntu/xenial64`.
-
-```sh
-vagrant up
-vagrant ssh
-make test
+```json
+{
+  "protoc": {
+    "options": [
+      "--proto_path=${workspaceRoot}/proto",
+      "--proto_path=${workspaceRoot}/third_party/proto"
+    ]
+  }
+}
 ```
 
 ## Changelog
@@ -229,6 +231,36 @@ Each PR should have one commit once it lands on `master`; this can be accomplish
 
 #### Major Release
 
+This major release process assumes that this release was preceded by release candidates.
+If there were no release candidates, and you'd like to cut a major release directly from master, see below.
+
+1. Start on the latest RC branch (`RCx/vX.X.0`).
+2. Run integration tests.
+3. Branch off of the RC branch (`git checkout -b release-prep`) and prepare the release:
+   - "Squash" changes from the changelog entries for the RCs into a single entry,
+      and add all changes included in `CHANGELOG_PENDING.md`.
+      (Squashing includes both combining all entries, as well as removing or simplifying
+      any intra-RC changes. It may also help to alphabetize the entries by package name.)
+   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for
+     all PRs
+   - Ensure that UPGRADING.md is up-to-date and includes notes on any breaking changes
+      or other upgrading flows.
+   - Bump P2P and block protocol versions in  `version.go`, if necessary
+   - Bump ABCI protocol version in `version.go`, if necessary
+   - Add any release notes you would like to be added to the body of the release to `release_notes.md`.
+4. Open a PR with these changes against the RC branch (`RCx/vX.X.0`).
+5. Once these changes are on the RC branch, branch off of the RC branch again to create a release branch:
+   - `git checkout RCx/vX.X.0`
+   - `git checkout -b release/vX.X.0`
+6. Push a tag with prepared release details. This will trigger the actual release `vX.X.0`.
+   - `git tag -a vX.X.0 -m 'Release vX.X.0'`
+   - `git push origin vX.X.0`
+7. Make sure that `master` is updated with the latest `CHANGELOG.md`, `CHANGELOG_PENDING.md`, and `UPGRADING.md`.
+8. Create the long-lived minor release branch `RC0/vX.X.1` for the next point release on this
+   new major release series.
+
+##### Major Release (from `master`)
+
 1. Start on `master`
 2. Run integration tests (see `test_integrations` in Makefile)
 3. Prepare release in a pull request against `master` (to be squash merged):
@@ -236,11 +268,10 @@ Each PR should have one commit once it lands on `master`; this can be accomplish
       had release candidates, squash all the RC updates into one
    - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for
      all issues
-   - run `bash ./scripts/authors.sh` to get a list of authors since the latest
+   - Run `bash ./scripts/authors.sh` to get a list of authors since the latest
      release, and add the github aliases of external contributors to the top of
      the changelog. To lookup an alias from an email, try `bash ./scripts/authors.sh <email>`
    - Reset the `CHANGELOG_PENDING.md`
-   - Bump TMVersionDefault version in  `version.go`
    - Bump P2P and block protocol versions in  `version.go`, if necessary
    - Bump ABCI protocol version in `version.go`, if necessary
    - Make sure all significant breaking changes are covered in `UPGRADING.md`
@@ -248,45 +279,41 @@ Each PR should have one commit once it lands on `master`; this can be accomplish
 4. Push a tag with prepared release details (this will trigger the release `vX.X.0`)
    - `git tag -a vX.X.x -m 'Release vX.X.x'`
    - `git push origin vX.X.x`
-5. Update the changelog.md file on master with the releases changelog.
+5. Update the `CHANGELOG.md` file on master with the releases changelog.
 6. Delete any RC branches and tags for this release (if applicable)
 
-#### Minor Release
+#### Minor Release (Point Releases)
 
-Minor releases are done differently from major releases: They are built off of long-lived release candidate branches, rather than from master.
+Minor releases are done differently from major releases: They are built off of long-lived backport branches, rather than from master.
+Each release "line" (e.g. 0.34 or 0.33) has its own long-lived backport branch, and
+the backport branches have names like `v0.34.x` or `v0.33.x` (literally, `x`; it is not a placeholder in this case).
 
-1. Checkout the long-lived release candidate branch: `git checkout rcX/vX.X.X`
+As non-breaking changes land on `master`, they should also be backported (cherry-picked) to these backport branches.
+
+We use Mergify's [backport feature](https://mergify.io/features/backports) to automatically backport to the needed branch. Depending on which backport branch you need to backport to there will be labels for them. To notify the bot to backport a pull request, mark the pull request with the label `backport-to-<backport_branch>`. Once the original pull request is merged, the bot will try to cherry-pick the pull request to the backport branch. If the bot fails to backport, it will open a pull request. The author of the original pull request is responsible for solving the conflicts and merging the pull request.
+
+Minor releases don't have release candidates by default, although any tricky changes may merit a release candidate.
+
+To create a minor release:
+
+1. Checkout the long-lived backport branch: `git checkout vX.X.x`
 2. Run integration tests: `make test_integrations`
-3. Prepare the release:
-   - copy `CHANGELOG_PENDING.md` to top of `CHANGELOG.md`
-   - run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for all issues
-   - run `bash ./scripts/authors.sh` to get a list of authors since the latest release, and add the GitHub aliases of external contributors to the top of the CHANGELOG. To lookup an alias from an email, try `bash ./scripts/authors.sh <email>`
-   - reset the `CHANGELOG_PENDING.md`
-   - bump P2P and block protocol versions in  `version.go`, if necessary
-   - bump ABCI protocol version in `version.go`, if necessary
-   - make sure all significant breaking changes are covered in `UPGRADING.md`
+3. Check out a new branch and prepare the release:
+   - Copy `CHANGELOG_PENDING.md` to top of `CHANGELOG.md`
+   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for all issues
+   - Run `bash ./scripts/authors.sh` to get a list of authors since the latest release, and add the GitHub aliases of external contributors to the top of the CHANGELOG. To lookup an alias from an email, try `bash ./scripts/authors.sh <email>`
+   - Reset the `CHANGELOG_PENDING.md`
+   - Bump the ABCI version number, if necessary.
+     (Note that ABCI follows semver, and that ABCI versions are the only versions
+     which can change during minor releases, and only field additions are valid minor changes.)
    - Add any release notes you would like to be added to the body of the release to `release_notes.md`.
-4. Create a release branch `release/vX.X.x` off the release candidate branch:
-   - `git checkout -b release/vX.X.x`
-   - `git push -u origin release/vX.X.x`
-   - Note that all branches prefixed with `release` are protected once pushed. You will need admin help to make any changes to the branch.
-5. Once the release branch has been approved, make sure to pull it locally, then push a tag.
+4. Open a PR with these changes that will land them back on `vX.X.x`
+5. Once this change has landed on the backport branch, make sure to pull it locally, then push a tag.
    - `git tag -a vX.X.x -m 'Release vX.X.x'`
    - `git push origin vX.X.x`
 6. Create a pull request back to master with the CHANGELOG & version changes from the latest release.
    - Remove all `R:minor` labels from the pull requests that were included in the release.
-   - Do not merge the release branch into master.
-7. Delete the former long lived release candidate branch once the release has been made.
-8. Create a new release candidate branch to be used for the next release.
-
-#### Backport Release
-
-1. start from the existing release branch you want to backport changes to (e.g. v0.30)
-   Branch to a release/vX.X.X branch locally (e.g. release/v0.30.7)
-2. Cherry pick the commit(s) that contain the changes you want to backport (usually these commits are from squash-merged PRs which were already reviewed)
-3. Follow steps 2 and 3 from [Major Release](#major-release)
-4. Push changes to release/vX.X.X branch
-5. Open a PR against the existing vX.X branch
+   - Do not merge the backport branch into master.
 
 #### Release Candidates
 
@@ -300,12 +327,12 @@ the "standard" release naming conventions, with `-rcX` at the end (`vX.X.X-rcX`)
 have distinct names from the tags/release names.)
 
 1. Start from the RC branch (e.g. `RC0/v0.34.0`).
-2. Create the new tag, specifying a name and a tag "message":  
-   `git tag -a v0.34.0-rc0 -m "Release Candidate v0.34.0-rc0` 
-3. Push the tag back up to origin:  
-   `git push origin v0.34.0-rc4`  
-   Now the tag should be available on the repo's releases page. 
-4. Create a new release candidate branch for any possible updates to the RC:  
+2. Create the new tag, specifying a name and a tag "message":
+   `git tag -a v0.34.0-rc0 -m "Release Candidate v0.34.0-rc0`
+3. Push the tag back up to origin:
+   `git push origin v0.34.0-rc4`
+   Now the tag should be available on the repo's releases page.
+4. Create a new release candidate branch for any possible updates to the RC:
    `git checkout -b RC1/v0.34.0; git push origin RC1/v0.34.0`
 
 ## Testing
@@ -340,15 +367,6 @@ cd test/e2e && \
   ./build/runner -f networks/ci.toml
 ```
 
-### Maverick
-
-**If you're changing the code in `consensus` package, please make sure to
-replicate all the changes in `./test/maverick/consensus`**. Maverick is a
-byzantine node used to assert that the validator gets punished for malicious
-behavior.
-
-See [README](./test/maverick/README.md) for details.
-
 ### Model-based tests (ADVANCED)
 
 *NOTE: if you're just submitting your first PR, you won't need to touch these
@@ -393,8 +411,10 @@ information.
 
 ### RPC Testing
 
-If you contribute to the RPC endpoints it's important to document your changes in the [Openapi file](./rpc/openapi/openapi.yaml)
-To test your changes you should install `nodejs` and run:
+**If you contribute to the RPC endpoints it's important to document your
+changes in the [Openapi file](./rpc/openapi/openapi.yaml)**.
+
+To test your changes you must install `nodejs` and run:
 
 ```bash
 npm i -g dredd

DOCKER/Dockerfile

@@ -49,7 +49,7 @@ ENV PROXY_APP=kvstore MONIKER=dockernode CHAIN_ID=dockerchain
 COPY ./DOCKER/docker-entrypoint.sh /usr/local/bin/
 
 ENTRYPOINT ["docker-entrypoint.sh"]
-CMD ["node"]
+CMD ["start"]
 
 # Expose the data directory as a volume since there's mutable state in there
 VOLUME [ "$TMHOME" ]

DOCKER/README.md

@@ -31,8 +31,8 @@ To get started developing applications, see the [application developers guide](h
 A quick example of a built-in app and Tendermint core in one container.
 
 ```sh
-docker run -it --rm -v "/tmp:/tendermint" tendermint/tendermint init
-docker run -it --rm -v "/tmp:/tendermint" tendermint/tendermint node --proxy_app=kvstore
+docker run -it --rm -v "/tmp:/tendermint" tendermint/tendermint init validator
+docker run -it --rm -v "/tmp:/tendermint" tendermint/tendermint start --proxy-app=kvstore
 ```
 
 ## Local cluster

DOCKER/docker-entrypoint.sh

@@ -3,14 +3,14 @@ set -e
 
 if [ ! -d "$TMHOME/config" ]; then
 	echo "Running tendermint init to create (default) configuration for docker run."
-	tendermint init
+	tendermint init validator
 
 	sed -i \
-		-e "s/^proxy_app\s*=.*/proxy_app = \"$PROXY_APP\"/" \
+		-e "s/^proxy-app\s*=.*/proxy-app = \"$PROXY_APP\"/" \
 		-e "s/^moniker\s*=.*/moniker = \"$MONIKER\"/" \
-		-e 's/^addr_book_strict\s*=.*/addr_book_strict = false/' \
-		-e 's/^timeout_commit\s*=.*/timeout_commit = "500ms"/' \
-		-e 's/^index_all_tags\s*=.*/index_all_tags = true/' \
+		-e 's/^addr-book-strict\s*=.*/addr-book-strict = false/' \
+		-e 's/^timeout-commit\s*=.*/timeout-commit = "500ms"/' \
+		-e 's/^index-all-tags\s*=.*/index-all-tags = true/' \
 		-e 's,^laddr = "tcp://127.0.0.1:26657",laddr = "tcp://0.0.0.0:26657",' \
 		-e 's/^prometheus\s*=.*/prometheus = true/' \
 		"$TMHOME/config/config.toml"

Makefile

@@ -1,5 +1,7 @@
+#!/usr/bin/make -f
+
 PACKAGES=$(shell go list ./...)
-OUTPUT?=build/tendermint
+BUILDDIR ?= $(CURDIR)/build
 
 BUILD_TAGS?=tendermint
 
@@ -13,6 +15,7 @@ endif
 LD_FLAGS = -X github.com/tendermint/tendermint/version.TMCoreSemVer=$(VERSION)
 BUILD_FLAGS = -mod=readonly -ldflags "$(LD_FLAGS)"
 HTTPS_GIT := https://github.com/tendermint/tendermint.git
+DOCKER_BUF := docker run -v $(shell pwd):/workspace --workdir /workspace bufbuild/buf
 CGO_ENABLED ?= 0
 
 # handle nostrip
@@ -55,73 +58,51 @@ LD_FLAGS += $(LDFLAGS)
 all: check build test install
 .PHONY: all
 
-include tests.mk
+include test/Makefile
 
 ###############################################################################
-###                                Build Tendermint                        ###
+###                                Build Tendermint                         ###
 ###############################################################################
 
-build:
-	CGO_ENABLED=$(CGO_ENABLED) go build $(BUILD_FLAGS) -tags '$(BUILD_TAGS)' -o $(OUTPUT) ./cmd/tendermint/
+build: $(BUILDDIR)/
+	CGO_ENABLED=$(CGO_ENABLED) go build $(BUILD_FLAGS) -tags '$(BUILD_TAGS)' -o $(BUILDDIR)/ ./cmd/tendermint/
 .PHONY: build
 
 install:
 	CGO_ENABLED=$(CGO_ENABLED) go install $(BUILD_FLAGS) -tags $(BUILD_TAGS) ./cmd/tendermint
 .PHONY: install
 
-
-###############################################################################
-###                                Mocks                                    ###
-###############################################################################
-
-mockery: 
-	go generate -run="./scripts/mockery_generate.sh" ./...
-.PHONY: mockery 
+$(BUILDDIR)/:
+	mkdir -p $@
 
 ###############################################################################
 ###                                Protobuf                                 ###
 ###############################################################################
 
-check-proto-deps:
-ifeq (,$(shell which protoc-gen-gogofaster))
-	@go install github.com/gogo/protobuf/protoc-gen-gogofaster@latest
-endif
-.PHONY: check-proto-deps
+proto-all: proto-gen proto-lint proto-check-breaking
+.PHONY: proto-all
 
-check-proto-format-deps:
-ifeq (,$(shell which clang-format))
-	$(error "clang-format is required for Protobuf formatting. See instructions for your platform on how to install it.")
-endif
-.PHONY: check-proto-format-deps
-
-proto-gen: check-proto-deps
+proto-gen:
+	@docker pull -q tendermintdev/docker-build-proto
 	@echo "Generating Protobuf files"
-	@go run github.com/bufbuild/buf/cmd/buf generate
-	@mv ./proto/tendermint/abci/types.pb.go ./abci/types/
+	@docker run -v $(shell pwd):/workspace --workdir /workspace tendermintdev/docker-build-proto sh ./scripts/protocgen.sh
 .PHONY: proto-gen
 
-# These targets are provided for convenience and are intended for local
-# execution only.
-proto-lint: check-proto-deps
-	@echo "Linting Protobuf files"
-	@go run github.com/bufbuild/buf/cmd/buf lint
+proto-lint:
+	@$(DOCKER_BUF) check lint --error-format=json
 .PHONY: proto-lint
 
-proto-format: check-proto-format-deps
+proto-format:
 	@echo "Formatting Protobuf files"
-	@find . -name '*.proto' -path "./proto/*" -exec clang-format -i {} \;
+	docker run -v $(shell pwd):/workspace --workdir /workspace tendermintdev/docker-build-proto find ./ -not -path "./third_party/*" -name *.proto -exec clang-format -i {} \;
 .PHONY: proto-format
 
-proto-check-breaking: check-proto-deps
-	@echo "Checking for breaking changes in Protobuf files against local branch"
-	@echo "Note: This is only useful if your changes have not yet been committed."
-	@echo "      Otherwise read up on buf's \"breaking\" command usage:"
-	@echo "      https://docs.buf.build/breaking/usage"
-	@go run github.com/bufbuild/buf/cmd/buf breaking --against ".git"
+proto-check-breaking:
+	@$(DOCKER_BUF) check breaking --against-input .git#branch=master
 .PHONY: proto-check-breaking
 
 proto-check-breaking-ci:
-	@go run github.com/bufbuild/buf/cmd/buf breaking --against $(HTTPS_GIT)#branch=v0.34.x
+	@$(DOCKER_BUF) check breaking --against-input $(HTTPS_GIT)#branch=master
 .PHONY: proto-check-breaking-ci
 
 ###############################################################################
@@ -136,6 +117,27 @@ install_abci:
 	@go install -mod=readonly ./abci/cmd/...
 .PHONY: install_abci
 
+###############################################################################
+###                           	Privval Server                              ###
+###############################################################################
+
+build_privval_server:
+	@go build -mod=readonly -o $(BUILDDIR)/ -i ./cmd/priv_val_server/...
+.PHONY: build_privval_server
+
+generate_test_cert:
+	# generate self signing ceritificate authority
+	@certstrap init --common-name "root CA" --expires "20 years"
+	# generate server cerificate
+	@certstrap request-cert -cn server -ip 127.0.0.1
+	# self-sign server cerificate with rootCA
+	@certstrap sign server --CA "root CA" 
+	# generate client cerificate
+	@certstrap request-cert -cn client -ip 127.0.0.1
+	# self-sign client cerificate with rootCA
+	@certstrap sign client --CA "root CA" 
+.PHONY: generate_test_cert
+
 ###############################################################################
 ###                              Distribution                               ###
 ###############################################################################
@@ -164,7 +166,7 @@ draw_deps:
 
 get_deps_bin_size:
 	@# Copy of build recipe with additional flags to perform binary size analysis
-	$(eval $(shell go build -work -a $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o $(OUTPUT) ./cmd/tendermint/ 2>&1))
+	$(eval $(shell go build -work -a $(BUILD_FLAGS) -tags $(BUILD_TAGS) -o $(BUILDDIR)/ ./cmd/tendermint/ 2>&1))
 	@find $(WORK) -type f -name "*.a" | xargs -I{} du -hxs "{}" | sort -rh | sed -e s:${WORK}/::g > deps_bin_size.log
 	@echo "Results can be found here: $(CURDIR)/deps_bin_size.log"
 .PHONY: get_deps_bin_size
@@ -208,31 +210,23 @@ DESTINATION = ./index.html.md
 ###############################################################################
 ###                           Documentation                                 ###
 ###############################################################################
-
+# todo remove once tendermint.com DNS is solved
 build-docs:
 	@cd docs && \
 	while read -r branch path_prefix; do \
-		(git checkout $${branch} && npm ci && VUEPRESS_BASE="/$${path_prefix}/" npm run build) ; \
+		(git checkout $${branch} && npm install && VUEPRESS_BASE="/$${path_prefix}/" npm run build) ; \
 		mkdir -p ~/output/$${path_prefix} ; \
 		cp -r .vuepress/dist/* ~/output/$${path_prefix}/ ; \
 		cp ~/output/$${path_prefix}/index.html ~/output ; \
 	done < versions ;
 .PHONY: build-docs
 
-sync-docs:
-	cd ~/output && \
-	echo "role_arn = ${DEPLOYMENT_ROLE_ARN}" >> /root/.aws/config ; \
-	echo "CI job = ${CIRCLE_BUILD_URL}" >> version.html ; \
-	aws s3 sync . s3://${WEBSITE_BUCKET} --profile terraform --delete ; \
-	aws cloudfront create-invalidation --distribution-id ${CF_DISTRIBUTION_ID} --profile terraform --path "/*" ;
-.PHONY: sync-docs
-
 ###############################################################################
 ###                            Docker image                                 ###
 ###############################################################################
 
 build-docker: build-linux
-	cp $(OUTPUT) DOCKER/tendermint
+	cp $(BUILDDIR)/tendermint DOCKER/tendermint
 	docker build --label=tendermint --tag="tendermint/tendermint" DOCKER
 	rm -rf DOCKER/tendermint
 .PHONY: build-docker
@@ -286,3 +280,17 @@ endif
 contract-tests:
 	dredd
 .PHONY: contract-tests
+
+clean:
+	rm -rf $(CURDIR)/artifacts/ $(BUILDDIR)/
+
+build-reproducible:
+	docker rm latest-build || true
+	docker run --volume=$(CURDIR):/sources:ro \
+		--env TARGET_PLATFORMS='linux/amd64 linux/arm64 darwin/amd64 windows/amd64' \
+		--env APP=tendermint \
+		--env COMMIT=$(shell git rev-parse --short=8 HEAD) \
+		--env VERSION=$(shell git describe --tags) \
+		--name latest-build cosmossdk/rbuilder:latest
+	docker cp -a latest-build:/home/builder/artifacts/ $(CURDIR)/
+.PHONY: build-reproducible

PHILOSOPHY.md

@@ -1,158 +0,0 @@
-# Design goals
-
-The design goals for Tendermint (and the SDK and related libraries) are:
-
-* Simplicity and Legibility
-* Parallel performance, namely ability to utilize multicore architecture
-* Ability to evolve the codebase bug-free
-* Debuggability
-* Complete correctness that considers all edge cases, esp in concurrency
-* Future-proof modular architecture, message protocol, APIs, and encapsulation
-
-
-## Justification
-
-Legibility is key to maintaining bug-free software as it evolves toward more
-optimizations, more ease of debugging, and additional features.
-
-It is too easy to introduce bugs over time by replacing lines of code with
-those that may panic, which means ideally locks are unlocked by defer
-statements.
-
-For example,
-
-```go
-func (obj *MyObj) something() {
-	mtx.Lock()
-	obj.something = other
-	mtx.Unlock()
-}
-```
-
-It is too easy to refactor the codebase in the future to replace `other` with
-`other.String()` for example, and this may introduce a bug that causes a
-deadlock.  So as much as reasonably possible, we need to be using defer
-statements, even though it introduces additional overhead.
-
-If it is necessary to optimize the unlocking of mutex locks, the solution is
-more modularity via smaller functions, so that defer'd unlocks are scoped
-within a smaller function.
-
-Similarly, idiomatic for-loops should always be preferred over those that use
-custom counters, because it is too easy to evolve the body of a for-loop to
-become more complicated over time, and it becomes more and more difficult to
-assess the correctness of such a for-loop by visual inspection.
-
-
-## On performance
-
-It doesn't matter whether there are alternative implementations that are 2x or
-3x more performant, when the software doesn't work, deadlocks, or if bugs
-cannot be debugged.  By taking advantage of multicore concurrency, the
-Tendermint implementation will at least be an order of magnitude within the
-range of what is theoretically possible.  The design philosophy of Tendermint,
-and the choice of Go as implementation language, is designed to make Tendermint
-implementation the standard specification for concurrent BFT software.
-
-By focusing on the message protocols (e.g. ABCI, p2p messages), and
-encapsulation e.g. IAVL module, (relatively) independent reactors, we are both
-implementing a standard implementation to be used as the specification for
-future implementations in more optimizable languages like Rust, Java, and C++;
-as well as creating sufficiently performant software. Tendermint Core will
-never be as fast as future implementations of the Tendermint Spec, because Go
-isn't designed to be as fast as possible.  The advantage of using Go is that we
-can develop the whole stack of modular components **faster** than in other
-languages.
-
-Furthermore, the real bottleneck is in the application layer, and it isn't
-necessary to support more than a sufficiently decentralized set of validators
-(e.g. 100 ~ 300 validators is sufficient, with delegated bonded PoS).
-
-Instead of optimizing Tendermint performance down to the metal, lets focus on
-optimizing on other matters, namely ability to push feature complete software
-that works well enough, can be debugged and maintained, and can serve as a spec
-for future implementations.
-
-
-## On encapsulation
-
-In order to create maintainable, forward-optimizable software, it is critical
-to develop well-encapsulated objects that have well understood properties, and
-to re-use these easy-to-use-correctly components as building blocks for further
-encapsulated meta-objects.
-
-For example, mutexes are cheap enough for Tendermint's design goals when there
-isn't goroutine contention, so it is encouraged to create concurrency safe
-structures with struct-level mutexes.  If they are used in the context of
-non-concurrent logic, then the performance is good enough.  If they are used in
-the context of concurrent logic, then it will still perform correctly.
-
-Examples of this design principle can be seen in the types.ValidatorSet struct,
-and the rand.Rand struct.  It's one single struct declaration that can be used
-in both concurrent and non-concurrent logic, and due to its well encapsulation,
-it's easy to get the usage of the mutex right.
-
-### example: rand.Rand
-
-`The default Source is safe for concurrent use by multiple goroutines, but
-Sources created by NewSource are not`.  The reason why the default
-package-level source is safe for concurrent use is because it is protected (see
-`lockedSource` in <https://golang.org/src/math/rand/rand.go>).
-
-But we shouldn't rely on the global source, we should be creating our own
-Rand/Source instances and using them, especially for determinism in testing.
-So it is reasonable to have rand.Rand be protected by a mutex.  Whether we want
-our own implementation of Rand is another question, but the answer there is
-also in the affirmative.  Sometimes you want to know where Rand is being used
-in your code, so it becomes a simple matter of dropping in a log statement to
-inject inspectability into Rand usage.  Also, it is nice to be able to extend
-the functionality of Rand with custom methods.  For these reasons, and for the
-reasons which is outlined in this design philosophy document, we should
-continue to use the rand.Rand object, with mutex protection.
-
-Another key aspect of good encapsulation is the choice of exposed vs unexposed
-methods.  It should be clear to the reader of the code, which methods are
-intended to be used in what context, and what safe usage is.  Part of this is
-solved by hiding methods via unexported methods.  Another part of this is
-naming conventions on the methods (e.g. underscores) with good documentation,
-and code organization.  If there are too many exposed methods and it isn't
-clear what methods have what side effects, then there is something wrong about
-the design of abstractions that should be revisited.
-
-
-## On concurrency
-
-In order for Tendermint to remain relevant in the years to come, it is vital
-for Tendermint to take advantage of multicore architectures.  Due to the nature
-of the problem, namely consensus across a concurrent p2p gossip network, and to
-handle RPC requests for a large number of consuming subscribers, it is
-unavoidable for Tendermint development to require expertise in concurrency
-design, especially when it comes to the reactor design, and also for RPC
-request handling.
-
-
-# Guidelines
-
-Here are some guidelines for designing for (sufficient) performance and concurrency:
-
-* Mutex locks are cheap enough when there isn't contention.
-* Do not optimize code without analytical or observed proof that it is in a hot path.
-* Don't over-use channels when mutex locks w/ encapsulation are sufficient.
-* The need to drain channels are often a hint of unconsidered edge cases.
-* The creation of O(N) one-off goroutines is generally technical debt that
-   needs to get addressed sooner than later.  Avoid creating too many
-goroutines as a patch around incomplete concurrency design, or at least be
-aware of the debt and do not invest in the debt.  On the other hand, Tendermint
-is designed to have a limited number of peers (e.g. 10 or 20), so the creation
-of O(C) goroutines per O(P) peers is still O(C\*P=constant).
-* Use defer statements to unlock as much as possible.  If you want to unlock sooner,
-    try to create more modular functions that do make use of defer statements.
-
-# Mantras
-
-* Premature optimization kills
-* Readability is paramount
-* Beautiful is better than fast.
-* In the face of ambiguity, refuse the temptation to guess.
-* In the face of bugs, refuse the temptation to cover the bug.
-* There should be one-- and preferably only one --obvious way to do it.

README.md

@@ -9,14 +9,14 @@ Or [Blockchain](<https://en.wikipedia.org/wiki/Blockchain_(database)>), for shor
 [![version](https://img.shields.io/github/tag/tendermint/tendermint.svg)](https://github.com/tendermint/tendermint/releases/latest)
 [![API Reference](https://camo.githubusercontent.com/915b7be44ada53c290eb157634330494ebe3e30a/68747470733a2f2f676f646f632e6f72672f6769746875622e636f6d2f676f6c616e672f6764646f3f7374617475732e737667)](https://pkg.go.dev/github.com/tendermint/tendermint)
 [![Go version](https://img.shields.io/badge/go-1.15-blue.svg)](https://github.com/moovweb/gvm)
-[![Discord chat](https://img.shields.io/discord/669268347736686612.svg)](https://discord.gg/AzefAFd)
+[![Discord chat](https://img.shields.io/discord/669268347736686612.svg)](https://discord.gg/vcExX9T)
 [![license](https://img.shields.io/github/license/tendermint/tendermint.svg)](https://github.com/tendermint/tendermint/blob/master/LICENSE)
 [![tendermint/tendermint](https://tokei.rs/b1/github/tendermint/tendermint?category=lines)](https://github.com/tendermint/tendermint)
 [![Sourcegraph](https://sourcegraph.com/github.com/tendermint/tendermint/-/badge.svg)](https://sourcegraph.com/github.com/tendermint/tendermint?badge)
 
-| Branch | Tests                                                                                                                                                                                                                                                  | Coverage                                                                                                                             | Linting                                                                    |
-| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------- |
-| master | [![CircleCI](https://circleci.com/gh/tendermint/tendermint/tree/master.svg?style=shield)](https://circleci.com/gh/tendermint/tendermint/tree/master) </br> ![Tests](https://github.com/tendermint/tendermint/workflows/Tests/badge.svg?branch=master) | [![codecov](https://codecov.io/gh/tendermint/tendermint/branch/master/graph/badge.svg)](https://codecov.io/gh/tendermint/tendermint) | ![Lint](https://github.com/tendermint/tendermint/workflows/Lint/badge.svg) |
+| Branch | Tests                                                                                      | Coverage                                                                                                                             | Linting                                                                    |
+|--------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------|
+| master | ![Tests](https://github.com/tendermint/tendermint/workflows/Tests/badge.svg?branch=master) | [![codecov](https://codecov.io/gh/tendermint/tendermint/branch/master/graph/badge.svg)](https://codecov.io/gh/tendermint/tendermint) | ![Lint](https://github.com/tendermint/tendermint/workflows/Lint/badge.svg) |
 
 Tendermint Core is Byzantine Fault Tolerant (BFT) middleware that takes a state transition machine - written in any programming language -
 and securely replicates it on many machines.
@@ -36,13 +36,13 @@ However, we are still making breaking changes to the protocol and the APIs and h
 See below for more details about [versioning](#versioning).
 
 In any case, if you intend to run Tendermint in production, we're happy to help. You can
-contact us [over email](mailto:hello@interchain.berlin) or [join the chat](https://discord.gg/AzefAFd).
+contact us [over email](mailto:hello@interchain.berlin) or [join the chat](https://discord.gg/vcExX9T).
 
 ## Security
 
 To report a security vulnerability, see our [bug bounty
 program](https://hackerone.com/tendermint). 
-For examples of the kinds of bugs we're looking for, see [our security policy](SECURITY.md)
+For examples of the kinds of bugs we're looking for, see [our security policy](SECURITY.md).
 
 We also maintain a dedicated mailing list for security updates. We will only ever use this mailing list
 to notify you of vulnerabilities and fixes in Tendermint Core. You can subscribe [here](http://eepurl.com/gZ5hQD).
@@ -50,7 +50,7 @@ to notify you of vulnerabilities and fixes in Tendermint Core. You can subscribe
 ## Minimum requirements
 
 | Requirement | Notes            |
-| ----------- | ---------------- |
+|-------------|------------------|
 | Go version  | Go1.15 or higher |
 
 ## Documentation
@@ -96,7 +96,6 @@ CHANGELOG even if they don't lead to MINOR version bumps:
 - crypto
 - config
 - libs
-    - bech32
     - bits
     - bytes
     - json
@@ -158,4 +157,14 @@ Additional tooling can be found in [/docs/tools](/docs/tools).
 - [The latest gossip on BFT consensus](https://arxiv.org/abs/1807.04938)
 - [Master's Thesis on Tendermint](https://atrium.lib.uoguelph.ca/xmlui/handle/10214/9769)
 - [Original Whitepaper: "Tendermint: Consensus Without Mining"](https://tendermint.com/static/docs/tendermint.pdf)
-- [Blog](https://blog.cosmos.network/tendermint/home)
+- [Tendermint Core Blog](https://medium.com/tendermint/tagged/tendermint-core)
+- [Cosmos Blog](https://blog.cosmos.network/tendermint/home)
+
+## Join us!
+
+Tendermint Core is maintained by [Interchain GmbH](https://interchain.berlin).
+If you'd like to work full-time on Tendermint Core, [we're hiring](https://interchain-gmbh.breezy.hr/p/682fb7e8a6f601-software-engineer-tendermint-core)!
+
+Funding for Tendermint Core development comes primarily from the [Interchain Foundation](https://interchain.io),
+a Swiss non-profit. The Tendermint trademark is owned by [Tendermint Inc.](https://tendermint.com), the for-profit entity
+ that also maintains [tendermint.com](https://tendermint.com).

SECURITY.md

@@ -7,54 +7,55 @@ Policy](https://tendermint.com/security), we operate a [bug
 bounty](https://hackerone.com/tendermint).
 See the policy for more details on submissions and rewards, and see "Example Vulnerabilities" (below) for examples of the kinds of bugs we're most interested in.
 
-### Guidelines 
+### Guidelines
 
 We require that all researchers:
 
 * Use the bug bounty to disclose all vulnerabilities, and avoid posting vulnerability information in public places, including Github Issues, Discord channels, and Telegram groups
 * Make every effort to avoid privacy violations, degradation of user experience, disruption to production systems (including but not limited to the Cosmos Hub), and destruction of data
-* Keep any information about vulnerabilities that you’ve discovered confidential between yourself and the Tendermint Core engineering team until the issue has been resolved and disclosed 
+* Keep any information about vulnerabilities that you’ve discovered confidential between yourself and the Tendermint Core engineering team until the issue has been resolved and disclosed
 * Avoid posting personally identifiable information, privately or publicly
 
 If you follow these guidelines when reporting an issue to us, we commit to:
 
 * Not pursue or support any legal action related to your research on this vulnerability
-* Work with you to understand, resolve and ultimately disclose the issue in a timely fashion 
+* Work with you to understand, resolve and ultimately disclose the issue in a timely fashion
 
-## Disclosure Process 
+## Disclosure Process
 
 Tendermint Core uses the following disclosure process:
 
-1. Once a security report is received, the Tendermint Core team works to verify the issue and confirm its severity level using CVSS. 
-2. The Tendermint Core team collaborates with the Gaia team to determine the vulnerability’s potential impact on the Cosmos Hub. 
-3. Patches are prepared for eligible releases of Tendermint in private repositories. See “Supported Releases” below for more information on which releases are considered eligible. 
-4. If it is determined that a CVE-ID is required, we request a CVE through a CVE Numbering Authority. 
+1. Once a security report is received, the Tendermint Core team works to verify the issue and confirm its severity level using CVSS.
+2. The Tendermint Core team collaborates with the Gaia team to determine the vulnerability’s potential impact on the Cosmos Hub.
+3. Patches are prepared for eligible releases of Tendermint in private repositories. See “Supported Releases” below for more information on which releases are considered eligible.
+4. If it is determined that a CVE-ID is required, we request a CVE through a CVE Numbering Authority.
 5. We notify the community that a security release is coming, to give users time to prepare their systems for the update. Notifications can include forum posts, tweets, and emails to partners and validators, including emails sent to the [Tendermint Security Mailing List](https://berlin.us4.list-manage.com/subscribe?u=431b35421ff7edcc77df5df10&id=3fe93307bc).
-6. 24 hours following this notification, the fixes are applied publicly and new releases are issued. 
-7. Cosmos SDK and Gaia update their Tendermint Core dependencies to use these releases, and then themselves issue new releases. 
-8. Once releases are available for Tendermint Core, Cosmos SDK and Gaia, we notify the community, again, through the same channels as above. We also publish a Security Advisory on Github and publish the CVE, as long as neither the Security Advisory nor the CVE include any information on how to exploit these vulnerabilities beyond what information is already available in the patch itself. 
-9. Once the community is notified, we will pay out any relevant bug bounties to submitters. 
-10. One week after the releases go out, we will publish a post with further details on the vulnerability as well as our response to it. 
+6. 24 hours following this notification, the fixes are applied publicly and new releases are issued.
+7. Cosmos SDK and Gaia update their Tendermint Core dependencies to use these releases, and then themselves issue new releases.
+8. Once releases are available for Tendermint Core, Cosmos SDK and Gaia, we notify the community, again, through the same channels as above. We also publish a Security Advisory on Github and publish the CVE, as long as neither the Security Advisory nor the CVE include any information on how to exploit these vulnerabilities beyond what information is already available in the patch itself.
+9. Once the community is notified, we will pay out any relevant bug bounties to submitters.
+10. One week after the releases go out, we will publish a post with further details on the vulnerability as well as our response to it.
 
-This process can take some time. Every effort will be made to handle the bug in as timely a manner as possible, however it's important that we follow the process described above to ensure that disclosures are handled consistently and to keep Tendermint Core and its downstream dependent projects--including but not limited to Gaia and the Cosmos Hub--as secure as possible. 
+This process can take some time. Every effort will be made to handle the bug in as timely a manner as possible, however it's important that we follow the process described above to ensure that disclosures are handled consistently and to keep Tendermint Core and its downstream dependent projects--including but not limited to Gaia and the Cosmos Hub--as secure as possible.
 
-### Example Timeline 
+### Example Timeline
 
-The following is an example timeline for the triage and response. The required roles and team members are described in parentheses after each task; however, multiple people can play each role and each person may play multiple roles. 
+The following is an example timeline for the triage and response. The required roles and team members are described in parentheses after each task; however, multiple people can play each role and each person may play multiple roles.
 
-#### > 24 Hours Before Release Time
+#### 24+ Hours Before Release Time
 
-1. Request CVE number (ADMIN) 
-2. Gather emails and other contact info for validators (COMMS LEAD) 
-3. Test fixes on a testnet  (TENDERMINT ENG, COSMOS ENG) 
-4. Write “Security Advisory” for forum (TENDERMINT LEAD) 
+1. Request CVE number (ADMIN)
+2. Gather emails and other contact info for validators (COMMS LEAD)
+3. Create patches in a private security repo, and ensure that PRs are open targeting all relevant release branches (TENDERMINT ENG, TENDERMINT LEAD)
+4. Test fixes on a testnet  (TENDERMINT ENG, COSMOS SDK ENG)
+5. Write “Security Advisory” for forum (TENDERMINT LEAD)
 
 #### 24 Hours Before Release Time
 
-1. Post “Security Advisory” pre-notification on forum (TENDERMINT LEAD) 
-2. Post Tweet linking to forum post (COMMS LEAD) 
-3. Announce security advisory/link to post in various other social channels (Telegram, Discord) (COMMS LEAD) 
-4. Send emails to validators or other users (PARTNERSHIPS LEAD) 
+1. Post “Security Advisory” pre-notification on forum (TENDERMINT LEAD)
+2. Post Tweet linking to forum post (COMMS LEAD)
+3. Announce security advisory/link to post in various other social channels (Telegram, Discord) (COMMS LEAD)
+4. Send emails to validators or other users (PARTNERSHIPS LEAD)
 
 #### Release Time
 
@@ -64,36 +65,36 @@ The following is an example timeline for the triage and response. The required r
 4. Post “Security releases” on forum (TENDERMINT LEAD)
 5. Post new Tweet linking to forum post (COMMS LEAD)
 6. Remind everyone via social channels (Telegram, Discord)  that the release is out (COMMS LEAD)
-7. Send emails to validators or other users (COMMS LEAD) 
-8. Publish Security Advisory and CVE, if CVE has no sensitive information (ADMIN) 
+7. Send emails to validators or other users (COMMS LEAD)
+8. Publish Security Advisory and CVE, if CVE has no sensitive information (ADMIN)
 
 #### After Release Time
 
 1. Write forum post with exploit details (TENDERMINT LEAD)
-2. Approve pay-out on HackerOne for submitter (ADMIN) 
+2. Approve pay-out on HackerOne for submitter (ADMIN)
 
 #### 7 Days After Release Time
 
-1. Publish CVE if it has not yet been published (ADMIN) 
+1. Publish CVE if it has not yet been published (ADMIN)
 2. Publish forum post with exploit details (TENDERMINT ENG, TENDERMINT LEAD)
 
 ## Supported Releases
 
-The Tendermint Core team commits to releasing security patch releases for both the latest minor release as well for the major/minor release that the Cosmos Hub is running. 
+The Tendermint Core team commits to releasing security patch releases for both the latest minor release as well for the major/minor release that the Cosmos Hub is running.
 
-If you are running older versions of Tendermint Core, we encourage you to upgrade at your earliest opportunity so that you can receive security patches directly from the Tendermint repo. While you are welcome to backport security patches to older versions for your own use, we will not publish or promote these backports. 
+If you are running older versions of Tendermint Core, we encourage you to upgrade at your earliest opportunity so that you can receive security patches directly from the Tendermint repo. While you are welcome to backport security patches to older versions for your own use, we will not publish or promote these backports.
 
 ## Scope
 
 The full scope of our bug bounty program is outlined on our [Hacker One program page](https://hackerone.com/tendermint). Please also note that, in the interest of the safety of our users and staff, a few things are explicitly excluded from scope:
 
-* Any third-party services 
-* Findings from physical testing, such as office access 
+* Any third-party services
+* Findings from physical testing, such as office access
 * Findings derived from social engineering (e.g., phishing)
 
-## Example Vulnerabilities 
+## Example Vulnerabilities
 
-The following is a list of examples of the kinds of vulnerabilities that we’re most interested in. It is not exhaustive: there are other kinds of issues we may also be interested in! 
+The following is a list of examples of the kinds of vulnerabilities that we’re most interested in. It is not exhaustive: there are other kinds of issues we may also be interested in!
 
 ### Specification
 
@@ -114,6 +115,9 @@ Assuming less than 1/3 of the voting power is Byzantine (malicious):
 * A node halting (liveness failure)
 * Syncing new and old nodes
 
+Assuming more than 1/3 the voting power is Byzantine:
+
+* Attacks that go unpunished (unhandled evidence)
 
 ### Networking
 
@@ -139,7 +143,7 @@ Attacks may come through the P2P network or the RPC layer:
 
 ### Libraries
 
-* Serialization (Amino)
+* Serialization
 * Reading/Writing files and databases
 
 ### Cryptography
@@ -150,5 +154,5 @@ Attacks may come through the P2P network or the RPC layer:
 
 ### Light Client
 
-* Core verification 
+* Core verification
 * Bisection/sequential algorithms

UPGRADING.md

@@ -2,13 +2,52 @@
 
 This guide provides instructions for upgrading to specific versions of Tendermint Core.
 
+## Unreleased
+
+### ABCI Changes
+
+* Added `AbciVersion` to `RequestInfo`. Applications should check that the ABCI version they expect is being used in order to avoid unimplemented changes errors.
+
+* The method `SetOption` has been removed from the ABCI.Client interface. This feature was used in the early ABCI implementation's.
+
+* Messages are written to a byte stream using uin64 length delimiters instead of int64.
+
+### Config Changes
+
+* `fast_sync = "v1"` is no longer supported. Please use `v2` instead.
+
+* All config parameters are now hyphen-case (also known as kebab-case) instead of snake_case. Before restarting the node make sure
+  you have updated all the variables in your `config.toml` file.
+
+* Added `--mode` flag and `mode` config variable on `config.toml` for setting Mode of the Node: `full` | `validator` | `seed` (default: `full`)
+  [ADR-52](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-052-tendermint-mode.md)
+  
+* `BootstrapPeers` has been added as part of the new p2p stack. This will eventually replace
+  `Seeds`. Bootstrap peers are connected with on startup if needed for peer discovery. Unlike
+  persistent peers, there's no gaurantee that the node will remain connected with these peers. 
+
+### CLI Changes
+
+* You must now specify the node mode (validator|full|seed) in `tendermint init [mode]`
+
+* If you had previously used `tendermint gen_node_key` to generate a new node
+  key, keep in mind that it no longer saves the output to a file. You can use
+  `tendermint init validator` or pipe the output of `tendermint gen_node_key` to
+  `$TMHOME/config/node_key.json`:
+
+  ```
+  $ tendermint gen_node_key > $TMHOME/config/node_key.json
+  ```
+
+* CLI commands and flags are all now hyphen-case instead of snake_case.
+  Make sure to adjust any scripts that calls a cli command with snake_casing
 ## v0.34.0
 
 **Upgrading to Tendermint 0.34 requires a blockchain restart.**
 This release is not compatible with previous blockchains due to changes to
 the encoding format (see "Protocol Buffers," below) and the block header (see "Blockchain Protocol").
 
-Note also that Tendermint 0.34 also requires Go 1.15 or higher. 
+Note also that Tendermint 0.34 also requires Go 1.15 or higher.
 
 ### ABCI Changes
 
@@ -42,6 +81,8 @@ Note also that Tendermint 0.34 also requires Go 1.15 or higher.
 * The field `Proof`, on the ABCI type `ResponseQuery`, is now named `ProofOps`.
   For more, see "Crypto," below.
 
+* The method `SetOption` has been removed from the ABCI.Client interface. This feature was used in the early ABCI implementation's.
+
 ### P2P Protocol
 
 The default codec is now proto3, not amino. The schema files can be found in the `/proto`
@@ -49,12 +90,9 @@ directory. For more, see "Protobuf," below.
 
 ### Blockchain Protocol
 
-* `Header#LastResultsHash` previously was the root hash of a Merkle tree built from `ResponseDeliverTx(Code, Data)` responses.
-  As of 0.34,`Header#LastResultsHash` is now the root hash of a Merkle tree built from:
-    * `BeginBlock#Events`
-    * Root hash of a Merkle tree built from `ResponseDeliverTx(Code, Data,
-      GasWanted, GasUsed, Events)` responses
-    * `BeginBlock#Events`
+* `Header#LastResultsHash`, which is the root hash of a Merkle tree built from
+`ResponseDeliverTx(Code, Data)` as of v0.34 also includes `GasWanted` and `GasUsed`
+fields.
 
 * Merkle hashes of empty trees previously returned nothing, but now return the hash of an empty input,
   to conform with [RFC-6962](https://tools.ietf.org/html/rfc6962).
@@ -112,7 +150,7 @@ Tendermint 0.34 includes new and updated consensus parameters.
 
 #### Evidence Parameters
 
-* `MaxBytes`, which caps the total amount of evidence. The default is 1048576 (1 MB). 
+* `MaxBytes`, which caps the total amount of evidence. The default is 1048576 (1 MB).
 
 ### Crypto
 
@@ -158,6 +196,7 @@ Other user-relevant changes include:
 * The `Verifier` was broken up into two pieces:
     * Core verification logic (pure `VerifyX` functions)
     * `Client` object, which represents the complete light client
+* The new light clients stores headers & validator sets as `LightBlock`s
 * The RPC client can be found in the `/rpc` directory.
 * The HTTP(S) proxy is located in the `/proxy` directory.
 
@@ -188,7 +227,7 @@ blockchains, we recommend that you check the chain ID.
 
 ### Version
 
-Version is now set through Go linker flags `ld_flags`. Applications that are using tendermint as a library should set this at compile time. 
+Version is now set through Go linker flags `ld_flags`. Applications that are using tendermint as a library should set this at compile time.
 
 Example:
 
@@ -196,7 +235,7 @@ Example:
 go install -mod=readonly -ldflags "-X github.com/tendermint/tendermint/version.TMCoreSemVer=$(go list -m github.com/tendermint/tendermint | sed  's/ /\@/g') -s -w " -trimpath ./cmd
 ```
 
-Additionally, the exported constant `version.Version` is now `version.TMCoreSemVer`. 
+Additionally, the exported constant `version.Version` is now `version.TMCoreSemVer`.
 
 ## v0.33.4
 
@@ -440,7 +479,7 @@ In this case, the WS client will receive an error with description:
   "error": {
     "code": -32000,
     "msg": "Server error",
-    "data": "subscription was cancelled (reason: client is not pulling messages fast enough)" // or "subscription was cancelled (reason: Tendermint exited)"
+    "data": "subscription was canceled (reason: client is not pulling messages fast enough)" // or "subscription was canceled (reason: Tendermint exited)"
   }
 }
 

Vagrantfile

@@ -1,66 +0,0 @@
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-Vagrant.configure("2") do |config|
-  config.vm.box = "ubuntu/focal64"
-
-  config.vm.provider "virtualbox" do |v|
-    v.memory = 4096
-    v.cpus = 2
-  end
-
-  config.vm.provision "shell", inline: <<-SHELL
-    apt-get update
-
-    # install base requirements
-    apt-get install -y --no-install-recommends wget curl jq zip \
-        make shellcheck bsdmainutils psmisc
-    apt-get install -y language-pack-en
-
-    # install docker
-    apt-get install -y --no-install-recommends apt-transport-https \
-      ca-certificates \
-      curl \
-      gnupg-agent \
-      software-properties-common
-    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -
-    add-apt-repository \
-      "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
-      $(lsb_release -cs) \
-      stable"
-    apt-get update
-    apt-get install -y docker-ce
-    usermod -aG docker vagrant
-
-    # install go
-    wget -q https://dl.google.com/go/go1.15.linux-amd64.tar.gz
-    tar -xvf go1.15.linux-amd64.tar.gz
-    mv go /usr/local
-    rm -f go1.15.linux-amd64.tar.gz
-
-    # install nodejs (for docs)
-    curl -sL https://deb.nodesource.com/setup_11.x | bash -
-    apt-get install -y nodejs
-
-    # cleanup
-    apt-get autoremove -y
-
-    # set env variables
-    echo 'export GOROOT=/usr/local/go' >> /home/vagrant/.bash_profile
-    echo 'export GOPATH=/home/vagrant/go' >> /home/vagrant/.bash_profile
-    echo 'export PATH=$PATH:$GOROOT/bin:$GOPATH/bin' >> /home/vagrant/.bash_profile
-    echo 'export LC_ALL=en_US.UTF-8' >> /home/vagrant/.bash_profile
-    echo 'cd go/src/github.com/tendermint/tendermint' >> /home/vagrant/.bash_profile
-
-    mkdir -p /home/vagrant/go/bin
-    mkdir -p /home/vagrant/go/src/github.com/tendermint
-    ln -s /vagrant /home/vagrant/go/src/github.com/tendermint/tendermint
-
-    chown -R vagrant:vagrant /home/vagrant/go
-    chown vagrant:vagrant /home/vagrant/.bash_profile
-
-    # get all deps and tools, ready to install/test
-    su - vagrant  -c 'source /home/vagrant/.bash_profile'
-    su - vagrant -c 'cd /home/vagrant/go/src/github.com/tendermint/tendermint && make tools'
-  SHELL
-end

abci/README.md

@@ -20,7 +20,7 @@ To get up and running quickly, see the [getting started guide](../docs/app-dev/g
 A detailed description of the ABCI methods and message types is contained in:
 
 - [The main spec](https://github.com/tendermint/spec/blob/master/spec/abci/abci.md)
-- [A protobuf file](./types/types.proto)
+- [A protobuf file](../proto/tendermint/abci/types.proto)
 - [A Go interface](./types/application.go)
 
 ## Protocol Buffers

abci/client/client.go

@@ -1,6 +1,7 @@
 package abcicli
 
 import (
+	"context"
 	"fmt"
 	"sync"
 
@@ -14,48 +15,53 @@ const (
 	echoRetryIntervalSeconds = 1
 )
 
+//go:generate mockery --case underscore --name Client
+
 // Client defines an interface for an ABCI client.
-// All `Async` methods return a `ReqRes` object.
+//
+// All `Async` methods return a `ReqRes` object and an error.
 // All `Sync` methods return the appropriate protobuf ResponseXxx struct and an error.
-// Note these are client errors, eg. ABCI socket connectivity issues.
-// Application-related errors are reflected in response via ABCI error codes and logs.
+//
+// NOTE these are client errors, eg. ABCI socket connectivity issues.
+// Application-related errors are reflected in response via ABCI error codes
+// and logs.
 type Client interface {
 	service.Service
 
 	SetResponseCallback(Callback)
 	Error() error
 
-	FlushAsync() *ReqRes
-	EchoAsync(msg string) *ReqRes
-	InfoAsync(types.RequestInfo) *ReqRes
-	SetOptionAsync(types.RequestSetOption) *ReqRes
-	DeliverTxAsync(types.RequestDeliverTx) *ReqRes
-	CheckTxAsync(types.RequestCheckTx) *ReqRes
-	QueryAsync(types.RequestQuery) *ReqRes
-	CommitAsync() *ReqRes
-	InitChainAsync(types.RequestInitChain) *ReqRes
-	BeginBlockAsync(types.RequestBeginBlock) *ReqRes
-	EndBlockAsync(types.RequestEndBlock) *ReqRes
-	ListSnapshotsAsync(types.RequestListSnapshots) *ReqRes
-	OfferSnapshotAsync(types.RequestOfferSnapshot) *ReqRes
-	LoadSnapshotChunkAsync(types.RequestLoadSnapshotChunk) *ReqRes
-	ApplySnapshotChunkAsync(types.RequestApplySnapshotChunk) *ReqRes
+	// Asynchronous requests
+	FlushAsync(context.Context) (*ReqRes, error)
+	EchoAsync(ctx context.Context, msg string) (*ReqRes, error)
+	InfoAsync(context.Context, types.RequestInfo) (*ReqRes, error)
+	DeliverTxAsync(context.Context, types.RequestDeliverTx) (*ReqRes, error)
+	CheckTxAsync(context.Context, types.RequestCheckTx) (*ReqRes, error)
+	QueryAsync(context.Context, types.RequestQuery) (*ReqRes, error)
+	CommitAsync(context.Context) (*ReqRes, error)
+	InitChainAsync(context.Context, types.RequestInitChain) (*ReqRes, error)
+	BeginBlockAsync(context.Context, types.RequestBeginBlock) (*ReqRes, error)
+	EndBlockAsync(context.Context, types.RequestEndBlock) (*ReqRes, error)
+	ListSnapshotsAsync(context.Context, types.RequestListSnapshots) (*ReqRes, error)
+	OfferSnapshotAsync(context.Context, types.RequestOfferSnapshot) (*ReqRes, error)
+	LoadSnapshotChunkAsync(context.Context, types.RequestLoadSnapshotChunk) (*ReqRes, error)
+	ApplySnapshotChunkAsync(context.Context, types.RequestApplySnapshotChunk) (*ReqRes, error)
 
-	FlushSync() error
-	EchoSync(msg string) (*types.ResponseEcho, error)
-	InfoSync(types.RequestInfo) (*types.ResponseInfo, error)
-	SetOptionSync(types.RequestSetOption) (*types.ResponseSetOption, error)
-	DeliverTxSync(types.RequestDeliverTx) (*types.ResponseDeliverTx, error)
-	CheckTxSync(types.RequestCheckTx) (*types.ResponseCheckTx, error)
-	QuerySync(types.RequestQuery) (*types.ResponseQuery, error)
-	CommitSync() (*types.ResponseCommit, error)
-	InitChainSync(types.RequestInitChain) (*types.ResponseInitChain, error)
-	BeginBlockSync(types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
-	EndBlockSync(types.RequestEndBlock) (*types.ResponseEndBlock, error)
-	ListSnapshotsSync(types.RequestListSnapshots) (*types.ResponseListSnapshots, error)
-	OfferSnapshotSync(types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)
-	LoadSnapshotChunkSync(types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)
-	ApplySnapshotChunkSync(types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error)
+	// Synchronous requests
+	FlushSync(context.Context) error
+	EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error)
+	InfoSync(context.Context, types.RequestInfo) (*types.ResponseInfo, error)
+	DeliverTxSync(context.Context, types.RequestDeliverTx) (*types.ResponseDeliverTx, error)
+	CheckTxSync(context.Context, types.RequestCheckTx) (*types.ResponseCheckTx, error)
+	QuerySync(context.Context, types.RequestQuery) (*types.ResponseQuery, error)
+	CommitSync(context.Context) (*types.ResponseCommit, error)
+	InitChainSync(context.Context, types.RequestInitChain) (*types.ResponseInitChain, error)
+	BeginBlockSync(context.Context, types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
+	EndBlockSync(context.Context, types.RequestEndBlock) (*types.ResponseEndBlock, error)
+	ListSnapshotsSync(context.Context, types.RequestListSnapshots) (*types.ResponseListSnapshots, error)
+	OfferSnapshotSync(context.Context, types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)
+	LoadSnapshotChunkSync(context.Context, types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)
+	ApplySnapshotChunkSync(context.Context, types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error)
 }
 
 //----------------------------------------
@@ -81,15 +87,9 @@ type ReqRes struct {
 	*sync.WaitGroup
 	*types.Response // Not set atomically, so be sure to use WaitGroup.
 
-	mtx tmsync.Mutex
-
-	// callbackInvoked as a variable to track if the callback was already
-	// invoked during the regular execution of the request. This variable
-	// allows clients to set the callback simultaneously without potentially
-	// invoking the callback twice by accident, once when 'SetCallback' is
-	// called and once during the normal request.
-	callbackInvoked bool
-	cb              func(*types.Response) // A single callback that may be set.
+	mtx  tmsync.RWMutex
+	done bool                  // Gets set to true once *after* WaitGroup.Done().
+	cb   func(*types.Response) // A single callback that may be set.
 }
 
 func NewReqRes(req *types.Request) *ReqRes {
@@ -98,8 +98,8 @@ func NewReqRes(req *types.Request) *ReqRes {
 		WaitGroup: waitGroup1(),
 		Response:  nil,
 
-		callbackInvoked: false,
-		cb:              nil,
+		done: false,
+		cb:   nil,
 	}
 }
 
@@ -109,7 +109,7 @@ func NewReqRes(req *types.Request) *ReqRes {
 func (r *ReqRes) SetCallback(cb func(res *types.Response)) {
 	r.mtx.Lock()
 
-	if r.callbackInvoked {
+	if r.done {
 		r.mtx.Unlock()
 		cb(r.Response)
 		return
@@ -128,7 +128,6 @@ func (r *ReqRes) InvokeCallback() {
 	if r.cb != nil {
 		r.cb(r.Response)
 	}
-	r.callbackInvoked = true
 }
 
 // GetCallback returns the configured callback of the ReqRes object which may be
@@ -138,9 +137,16 @@ func (r *ReqRes) InvokeCallback() {
 //
 // ref: https://github.com/tendermint/tendermint/issues/5439
 func (r *ReqRes) GetCallback() func(*types.Response) {
+	r.mtx.RLock()
+	defer r.mtx.RUnlock()
+	return r.cb
+}
+
+// SetDone marks the ReqRes object as done.
+func (r *ReqRes) SetDone() {
 	r.mtx.Lock()
 	defer r.mtx.Unlock()
-	return r.cb
+	r.done = true
 }
 
 func waitGroup1() (wg *sync.WaitGroup) {

abci/client/doc.go

@@ -0,0 +1,29 @@
+// Package abcicli provides an ABCI implementation in Go.
+//
+// There are 3 clients available:
+//		1. socket (unix or TCP)
+//		2. local (in memory)
+//		3. gRPC
+//
+// ## Socket client
+//
+// async: the client maintains an internal buffer of a fixed size. when the
+// buffer becomes full, all Async calls will return an error immediately.
+//
+// sync: the client blocks on 1) enqueuing the Sync request 2) enqueuing the
+// Flush requests 3) waiting for the Flush response
+//
+// ## Local client
+//
+// async: global mutex is locked during each call (meaning it's not really async!)
+// sync: global mutex is locked during each call
+//
+// ## gRPC client
+//
+// async: gRPC is synchronous, but an internal buffer of a fixed size is used
+// to store responses and later call callbacks (separate goroutine per
+// response).
+//
+// sync: waits for all Async calls to complete (essentially what Flush does in
+// the socket client) and calls Sync method.
+package abcicli

abci/client/grpc_client.go

@@ -1,12 +1,12 @@
 package abcicli
 
 import (
+	"context"
 	"fmt"
 	"net"
 	"sync"
 	"time"
 
-	"golang.org/x/net/context"
 	"google.golang.org/grpc"
 
 	"github.com/tendermint/tendermint/abci/types"
@@ -15,10 +15,7 @@ import (
 	tmsync "github.com/tendermint/tendermint/libs/sync"
 )
 
-var _ Client = (*grpcClient)(nil)
-
-// A stripped copy of the remoteClient that makes
-// synchronous calls using grpc
+// A gRPC client.
 type grpcClient struct {
 	service.BaseService
 	mustConnect bool
@@ -27,12 +24,24 @@ type grpcClient struct {
 	conn     *grpc.ClientConn
 	chReqRes chan *ReqRes // dispatches "async" responses to callbacks *in order*, needed by mempool
 
-	mtx   tmsync.Mutex
+	mtx   tmsync.RWMutex
 	addr  string
 	err   error
 	resCb func(*types.Request, *types.Response) // listens to all callbacks
 }
 
+var _ Client = (*grpcClient)(nil)
+
+// NewGRPCClient creates a gRPC client, which will connect to addr upon the
+// start. Note Client#Start returns an error if connection is unsuccessful and
+// mustConnect is true.
+//
+// GRPC calls are synchronous, but some callbacks expect to be called
+// asynchronously (eg. the mempool expects to be able to lock to remove bad txs
+// from cache). To accommodate, we finish each call in its own go-routine,
+// which is expensive, but easy - if you want something better, use the socket
+// protocol! maybe one day, if people really want it, we use grpc streams, but
+// hopefully not :D
 func NewGRPCClient(addr string, mustConnect bool) Client {
 	cli := &grpcClient{
 		addr:        addr,
@@ -54,10 +63,6 @@ func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
 }
 
 func (cli *grpcClient) OnStart() error {
-	if err := cli.BaseService.OnStart(); err != nil {
-		return err
-	}
-
 	// This processes asynchronous request/response messages and dispatches
 	// them to callbacks.
 	go func() {
@@ -66,6 +71,7 @@ func (cli *grpcClient) OnStart() error {
 			cli.mtx.Lock()
 			defer cli.mtx.Unlock()
 
+			reqres.SetDone()
 			reqres.Done()
 
 			// Notify client listener if set
@@ -74,7 +80,9 @@ func (cli *grpcClient) OnStart() error {
 			}
 
 			// Notify reqRes listener if set
-			reqres.InvokeCallback()
+			if cb := reqres.GetCallback(); cb != nil {
+				cb(reqres.Response)
+			}
 		}
 		for reqres := range cli.chReqRes {
 			if reqres != nil {
@@ -87,7 +95,6 @@ func (cli *grpcClient) OnStart() error {
 
 RETRY_LOOP:
 	for {
-		//nolint:staticcheck // SA1019 Existing use of deprecated but supported dial option.
 		conn, err := grpc.Dial(cli.addr, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
 		if err != nil {
 			if cli.mustConnect {
@@ -118,8 +125,6 @@ RETRY_LOOP:
 }
 
 func (cli *grpcClient) OnStop() {
-	cli.BaseService.OnStop()
-
 	if cli.conn != nil {
 		cli.conn.Close()
 	}
@@ -144,8 +149,8 @@ func (cli *grpcClient) StopForError(err error) {
 }
 
 func (cli *grpcClient) Error() error {
-	cli.mtx.Lock()
-	defer cli.mtx.Unlock()
+	cli.mtx.RLock()
+	defer cli.mtx.RUnlock()
 	return cli.err
 }
 
@@ -153,160 +158,173 @@ func (cli *grpcClient) Error() error {
 // NOTE: callback may get internally generated flush responses.
 func (cli *grpcClient) SetResponseCallback(resCb Callback) {
 	cli.mtx.Lock()
+	defer cli.mtx.Unlock()
 	cli.resCb = resCb
-	cli.mtx.Unlock()
 }
 
 //----------------------------------------
-// GRPC calls are synchronous, but some callbacks expect to be called asynchronously
-// (eg. the mempool expects to be able to lock to remove bad txs from cache).
-// To accommodate, we finish each call in its own go-routine,
-// which is expensive, but easy - if you want something better, use the socket protocol!
-// maybe one day, if people really want it, we use grpc streams,
-// but hopefully not :D
 
-func (cli *grpcClient) EchoAsync(msg string) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, error) {
 	req := types.ToRequestEcho(msg)
-	res, err := cli.client.Echo(context.Background(), req.GetEcho(), grpc.WaitForReady(true))
+	res, err := cli.client.Echo(ctx, req.GetEcho(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Echo{Echo: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Echo{Echo: res}})
 }
 
-func (cli *grpcClient) FlushAsync() *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) FlushAsync(ctx context.Context) (*ReqRes, error) {
 	req := types.ToRequestFlush()
-	res, err := cli.client.Flush(context.Background(), req.GetFlush(), grpc.WaitForReady(true))
+	res, err := cli.client.Flush(ctx, req.GetFlush(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Flush{Flush: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Flush{Flush: res}})
 }
 
-func (cli *grpcClient) InfoAsync(params types.RequestInfo) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) InfoAsync(ctx context.Context, params types.RequestInfo) (*ReqRes, error) {
 	req := types.ToRequestInfo(params)
-	res, err := cli.client.Info(context.Background(), req.GetInfo(), grpc.WaitForReady(true))
+	res, err := cli.client.Info(ctx, req.GetInfo(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Info{Info: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Info{Info: res}})
 }
 
-func (cli *grpcClient) SetOptionAsync(params types.RequestSetOption) *ReqRes {
-	req := types.ToRequestSetOption(params)
-	res, err := cli.client.SetOption(context.Background(), req.GetSetOption(), grpc.WaitForReady(true))
-	if err != nil {
-		cli.StopForError(err)
-	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_SetOption{SetOption: res}})
-}
-
-func (cli *grpcClient) DeliverTxAsync(params types.RequestDeliverTx) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) DeliverTxAsync(ctx context.Context, params types.RequestDeliverTx) (*ReqRes, error) {
 	req := types.ToRequestDeliverTx(params)
-	res, err := cli.client.DeliverTx(context.Background(), req.GetDeliverTx(), grpc.WaitForReady(true))
+	res, err := cli.client.DeliverTx(ctx, req.GetDeliverTx(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_DeliverTx{DeliverTx: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_DeliverTx{DeliverTx: res}})
 }
 
-func (cli *grpcClient) CheckTxAsync(params types.RequestCheckTx) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) CheckTxAsync(ctx context.Context, params types.RequestCheckTx) (*ReqRes, error) {
 	req := types.ToRequestCheckTx(params)
-	res, err := cli.client.CheckTx(context.Background(), req.GetCheckTx(), grpc.WaitForReady(true))
+	res, err := cli.client.CheckTx(ctx, req.GetCheckTx(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_CheckTx{CheckTx: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_CheckTx{CheckTx: res}})
 }
 
-func (cli *grpcClient) QueryAsync(params types.RequestQuery) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) QueryAsync(ctx context.Context, params types.RequestQuery) (*ReqRes, error) {
 	req := types.ToRequestQuery(params)
-	res, err := cli.client.Query(context.Background(), req.GetQuery(), grpc.WaitForReady(true))
+	res, err := cli.client.Query(ctx, req.GetQuery(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Query{Query: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Query{Query: res}})
 }
 
-func (cli *grpcClient) CommitAsync() *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) CommitAsync(ctx context.Context) (*ReqRes, error) {
 	req := types.ToRequestCommit()
-	res, err := cli.client.Commit(context.Background(), req.GetCommit(), grpc.WaitForReady(true))
+	res, err := cli.client.Commit(ctx, req.GetCommit(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_Commit{Commit: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Commit{Commit: res}})
 }
 
-func (cli *grpcClient) InitChainAsync(params types.RequestInitChain) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) InitChainAsync(ctx context.Context, params types.RequestInitChain) (*ReqRes, error) {
 	req := types.ToRequestInitChain(params)
-	res, err := cli.client.InitChain(context.Background(), req.GetInitChain(), grpc.WaitForReady(true))
+	res, err := cli.client.InitChain(ctx, req.GetInitChain(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_InitChain{InitChain: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_InitChain{InitChain: res}})
 }
 
-func (cli *grpcClient) BeginBlockAsync(params types.RequestBeginBlock) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) BeginBlockAsync(ctx context.Context, params types.RequestBeginBlock) (*ReqRes, error) {
 	req := types.ToRequestBeginBlock(params)
-	res, err := cli.client.BeginBlock(context.Background(), req.GetBeginBlock(), grpc.WaitForReady(true))
+	res, err := cli.client.BeginBlock(ctx, req.GetBeginBlock(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_BeginBlock{BeginBlock: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_BeginBlock{BeginBlock: res}})
 }
 
-func (cli *grpcClient) EndBlockAsync(params types.RequestEndBlock) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) EndBlockAsync(ctx context.Context, params types.RequestEndBlock) (*ReqRes, error) {
 	req := types.ToRequestEndBlock(params)
-	res, err := cli.client.EndBlock(context.Background(), req.GetEndBlock(), grpc.WaitForReady(true))
+	res, err := cli.client.EndBlock(ctx, req.GetEndBlock(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_EndBlock{EndBlock: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_EndBlock{EndBlock: res}})
 }
 
-func (cli *grpcClient) ListSnapshotsAsync(params types.RequestListSnapshots) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) ListSnapshotsAsync(ctx context.Context, params types.RequestListSnapshots) (*ReqRes, error) {
 	req := types.ToRequestListSnapshots(params)
-	res, err := cli.client.ListSnapshots(context.Background(), req.GetListSnapshots(), grpc.WaitForReady(true))
+	res, err := cli.client.ListSnapshots(ctx, req.GetListSnapshots(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ListSnapshots{ListSnapshots: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_ListSnapshots{ListSnapshots: res}})
 }
 
-func (cli *grpcClient) OfferSnapshotAsync(params types.RequestOfferSnapshot) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) OfferSnapshotAsync(ctx context.Context, params types.RequestOfferSnapshot) (*ReqRes, error) {
 	req := types.ToRequestOfferSnapshot(params)
-	res, err := cli.client.OfferSnapshot(context.Background(), req.GetOfferSnapshot(), grpc.WaitForReady(true))
+	res, err := cli.client.OfferSnapshot(ctx, req.GetOfferSnapshot(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_OfferSnapshot{OfferSnapshot: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_OfferSnapshot{OfferSnapshot: res}})
 }
 
-func (cli *grpcClient) LoadSnapshotChunkAsync(params types.RequestLoadSnapshotChunk) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) LoadSnapshotChunkAsync(
+	ctx context.Context,
+	params types.RequestLoadSnapshotChunk,
+) (*ReqRes, error) {
 	req := types.ToRequestLoadSnapshotChunk(params)
-	res, err := cli.client.LoadSnapshotChunk(context.Background(), req.GetLoadSnapshotChunk(), grpc.WaitForReady(true))
+	res, err := cli.client.LoadSnapshotChunk(ctx, req.GetLoadSnapshotChunk(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_LoadSnapshotChunk{LoadSnapshotChunk: res}})
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_LoadSnapshotChunk{LoadSnapshotChunk: res}})
 }
 
-func (cli *grpcClient) ApplySnapshotChunkAsync(params types.RequestApplySnapshotChunk) *ReqRes {
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) ApplySnapshotChunkAsync(
+	ctx context.Context,
+	params types.RequestApplySnapshotChunk,
+) (*ReqRes, error) {
 	req := types.ToRequestApplySnapshotChunk(params)
-	res, err := cli.client.ApplySnapshotChunk(context.Background(), req.GetApplySnapshotChunk(), grpc.WaitForReady(true))
+	res, err := cli.client.ApplySnapshotChunk(ctx, req.GetApplySnapshotChunk(), grpc.WaitForReady(true))
 	if err != nil {
-		cli.StopForError(err)
+		return nil, err
 	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ApplySnapshotChunk{ApplySnapshotChunk: res}})
+	return cli.finishAsyncCall(
+		ctx,
+		req,
+		&types.Response{Value: &types.Response_ApplySnapshotChunk{ApplySnapshotChunk: res}},
+	)
 }
 
 // finishAsyncCall creates a ReqRes for an async call, and immediately populates it
 // with the response. We don't complete it until it's been ordered via the channel.
-func (cli *grpcClient) finishAsyncCall(req *types.Request, res *types.Response) *ReqRes {
+func (cli *grpcClient) finishAsyncCall(ctx context.Context, req *types.Request, res *types.Response) (*ReqRes, error) {
 	reqres := NewReqRes(req)
 	reqres.Response = res
-	cli.chReqRes <- reqres // use channel for async responses, since they must be ordered
-	return reqres
+	select {
+	case cli.chReqRes <- reqres: // use channel for async responses, since they must be ordered
+		return reqres, nil
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
 }
 
 // finishSyncCall waits for an async call to complete. It is necessary to call all
@@ -339,81 +357,150 @@ func (cli *grpcClient) finishSyncCall(reqres *ReqRes) *types.Response {
 
 //----------------------------------------
 
-func (cli *grpcClient) FlushSync() error {
-	reqres := cli.FlushAsync()
-	cli.finishSyncCall(reqres).GetFlush()
-	return cli.Error()
+func (cli *grpcClient) FlushSync(ctx context.Context) error {
+	return nil
 }
 
-func (cli *grpcClient) EchoSync(msg string) (*types.ResponseEcho, error) {
-	reqres := cli.EchoAsync(msg)
-	// StopForError should already have been called if error is set
+func (cli *grpcClient) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+	reqres, err := cli.EchoAsync(ctx, msg)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetEcho(), cli.Error()
 }
 
-func (cli *grpcClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, error) {
-	reqres := cli.InfoAsync(req)
+func (cli *grpcClient) InfoSync(
+	ctx context.Context,
+	req types.RequestInfo,
+) (*types.ResponseInfo, error) {
+	reqres, err := cli.InfoAsync(ctx, req)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetInfo(), cli.Error()
 }
 
-func (cli *grpcClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
-	reqres := cli.SetOptionAsync(req)
-	return reqres.Response.GetSetOption(), cli.Error()
-}
+func (cli *grpcClient) DeliverTxSync(
+	ctx context.Context,
+	params types.RequestDeliverTx,
+) (*types.ResponseDeliverTx, error) {
 
-func (cli *grpcClient) DeliverTxSync(params types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
-	reqres := cli.DeliverTxAsync(params)
+	reqres, err := cli.DeliverTxAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetDeliverTx(), cli.Error()
 }
 
-func (cli *grpcClient) CheckTxSync(params types.RequestCheckTx) (*types.ResponseCheckTx, error) {
-	reqres := cli.CheckTxAsync(params)
+func (cli *grpcClient) CheckTxSync(
+	ctx context.Context,
+	params types.RequestCheckTx,
+) (*types.ResponseCheckTx, error) {
+
+	reqres, err := cli.CheckTxAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetCheckTx(), cli.Error()
 }
 
-func (cli *grpcClient) QuerySync(req types.RequestQuery) (*types.ResponseQuery, error) {
-	reqres := cli.QueryAsync(req)
+func (cli *grpcClient) QuerySync(
+	ctx context.Context,
+	req types.RequestQuery,
+) (*types.ResponseQuery, error) {
+	reqres, err := cli.QueryAsync(ctx, req)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetQuery(), cli.Error()
 }
 
-func (cli *grpcClient) CommitSync() (*types.ResponseCommit, error) {
-	reqres := cli.CommitAsync()
+func (cli *grpcClient) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
+	reqres, err := cli.CommitAsync(ctx)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetCommit(), cli.Error()
 }
 
-func (cli *grpcClient) InitChainSync(params types.RequestInitChain) (*types.ResponseInitChain, error) {
-	reqres := cli.InitChainAsync(params)
+func (cli *grpcClient) InitChainSync(
+	ctx context.Context,
+	params types.RequestInitChain,
+) (*types.ResponseInitChain, error) {
+
+	reqres, err := cli.InitChainAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetInitChain(), cli.Error()
 }
 
-func (cli *grpcClient) BeginBlockSync(params types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
-	reqres := cli.BeginBlockAsync(params)
+func (cli *grpcClient) BeginBlockSync(
+	ctx context.Context,
+	params types.RequestBeginBlock,
+) (*types.ResponseBeginBlock, error) {
+
+	reqres, err := cli.BeginBlockAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetBeginBlock(), cli.Error()
 }
 
-func (cli *grpcClient) EndBlockSync(params types.RequestEndBlock) (*types.ResponseEndBlock, error) {
-	reqres := cli.EndBlockAsync(params)
+func (cli *grpcClient) EndBlockSync(
+	ctx context.Context,
+	params types.RequestEndBlock,
+) (*types.ResponseEndBlock, error) {
+
+	reqres, err := cli.EndBlockAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetEndBlock(), cli.Error()
 }
 
-func (cli *grpcClient) ListSnapshotsSync(params types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
-	reqres := cli.ListSnapshotsAsync(params)
+func (cli *grpcClient) ListSnapshotsSync(
+	ctx context.Context,
+	params types.RequestListSnapshots,
+) (*types.ResponseListSnapshots, error) {
+
+	reqres, err := cli.ListSnapshotsAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetListSnapshots(), cli.Error()
 }
 
-func (cli *grpcClient) OfferSnapshotSync(params types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
-	reqres := cli.OfferSnapshotAsync(params)
+func (cli *grpcClient) OfferSnapshotSync(
+	ctx context.Context,
+	params types.RequestOfferSnapshot,
+) (*types.ResponseOfferSnapshot, error) {
+
+	reqres, err := cli.OfferSnapshotAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetOfferSnapshot(), cli.Error()
 }
 
 func (cli *grpcClient) LoadSnapshotChunkSync(
+	ctx context.Context,
 	params types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
-	reqres := cli.LoadSnapshotChunkAsync(params)
+
+	reqres, err := cli.LoadSnapshotChunkAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetLoadSnapshotChunk(), cli.Error()
 }
 
 func (cli *grpcClient) ApplySnapshotChunkSync(
+	ctx context.Context,
 	params types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
-	reqres := cli.ApplySnapshotChunkAsync(params)
+
+	reqres, err := cli.ApplySnapshotChunkAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
 	return cli.finishSyncCall(reqres).GetApplySnapshotChunk(), cli.Error()
 }

abci/client/local_client.go

@@ -1,13 +1,13 @@
 package abcicli
 
 import (
+	"context"
+
 	types "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/service"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
 )
 
-var _ Client = (*localClient)(nil)
-
 // NOTE: use defer to unlock mutex because Application might panic (e.g., in
 // case of malicious tx or query). It only makes sense for publicly exposed
 // methods like CheckTx (/broadcast_tx_* RPC endpoint) or Query (/abci_query
@@ -15,7 +15,7 @@ var _ Client = (*localClient)(nil)
 type localClient struct {
 	service.BaseService
 
-	mtx *tmsync.Mutex
+	mtx *tmsync.RWMutex
 	types.Application
 	Callback
 }
@@ -26,22 +26,24 @@ var _ Client = (*localClient)(nil)
 // methods of the given app.
 //
 // Both Async and Sync methods ignore the given context.Context parameter.
-func NewLocalClient(mtx *tmsync.Mutex, app types.Application) Client {
+func NewLocalClient(mtx *tmsync.RWMutex, app types.Application) Client {
 	if mtx == nil {
-		mtx = new(tmsync.Mutex)
+		mtx = &tmsync.RWMutex{}
 	}
+
 	cli := &localClient{
 		mtx:         mtx,
 		Application: app,
 	}
+
 	cli.BaseService = *service.NewBaseService(nil, "localClient", cli)
 	return cli
 }
 
 func (app *localClient) SetResponseCallback(cb Callback) {
 	app.mtx.Lock()
+	defer app.mtx.Unlock()
 	app.Callback = cb
-	app.mtx.Unlock()
 }
 
 // TODO: change types.Application to include Error()?
@@ -49,44 +51,33 @@ func (app *localClient) Error() error {
 	return nil
 }
 
-func (app *localClient) FlushAsync() *ReqRes {
+func (app *localClient) FlushAsync(ctx context.Context) (*ReqRes, error) {
 	// Do nothing
-	return newLocalReqRes(types.ToRequestFlush(), nil)
+	return newLocalReqRes(types.ToRequestFlush(), nil), nil
 }
 
-func (app *localClient) EchoAsync(msg string) *ReqRes {
+func (app *localClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
 	return app.callback(
 		types.ToRequestEcho(msg),
 		types.ToResponseEcho(msg),
-	)
+	), nil
 }
 
-func (app *localClient) InfoAsync(req types.RequestInfo) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+func (app *localClient) InfoAsync(ctx context.Context, req types.RequestInfo) (*ReqRes, error) {
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Info(req)
 	return app.callback(
 		types.ToRequestInfo(req),
 		types.ToResponseInfo(res),
-	)
+	), nil
 }
 
-func (app *localClient) SetOptionAsync(req types.RequestSetOption) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.SetOption(req)
-	return app.callback(
-		types.ToRequestSetOption(req),
-		types.ToResponseSetOption(res),
-	)
-}
-
-func (app *localClient) DeliverTxAsync(params types.RequestDeliverTx) *ReqRes {
+func (app *localClient) DeliverTxAsync(ctx context.Context, params types.RequestDeliverTx) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -94,10 +85,10 @@ func (app *localClient) DeliverTxAsync(params types.RequestDeliverTx) *ReqRes {
 	return app.callback(
 		types.ToRequestDeliverTx(params),
 		types.ToResponseDeliverTx(res),
-	)
+	), nil
 }
 
-func (app *localClient) CheckTxAsync(req types.RequestCheckTx) *ReqRes {
+func (app *localClient) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -105,21 +96,21 @@ func (app *localClient) CheckTxAsync(req types.RequestCheckTx) *ReqRes {
 	return app.callback(
 		types.ToRequestCheckTx(req),
 		types.ToResponseCheckTx(res),
-	)
+	), nil
 }
 
-func (app *localClient) QueryAsync(req types.RequestQuery) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+func (app *localClient) QueryAsync(ctx context.Context, req types.RequestQuery) (*ReqRes, error) {
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Query(req)
 	return app.callback(
 		types.ToRequestQuery(req),
 		types.ToResponseQuery(res),
-	)
+	), nil
 }
 
-func (app *localClient) CommitAsync() *ReqRes {
+func (app *localClient) CommitAsync(ctx context.Context) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -127,10 +118,10 @@ func (app *localClient) CommitAsync() *ReqRes {
 	return app.callback(
 		types.ToRequestCommit(),
 		types.ToResponseCommit(res),
-	)
+	), nil
 }
 
-func (app *localClient) InitChainAsync(req types.RequestInitChain) *ReqRes {
+func (app *localClient) InitChainAsync(ctx context.Context, req types.RequestInitChain) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -138,10 +129,10 @@ func (app *localClient) InitChainAsync(req types.RequestInitChain) *ReqRes {
 	return app.callback(
 		types.ToRequestInitChain(req),
 		types.ToResponseInitChain(res),
-	)
+	), nil
 }
 
-func (app *localClient) BeginBlockAsync(req types.RequestBeginBlock) *ReqRes {
+func (app *localClient) BeginBlockAsync(ctx context.Context, req types.RequestBeginBlock) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -149,10 +140,10 @@ func (app *localClient) BeginBlockAsync(req types.RequestBeginBlock) *ReqRes {
 	return app.callback(
 		types.ToRequestBeginBlock(req),
 		types.ToResponseBeginBlock(res),
-	)
+	), nil
 }
 
-func (app *localClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes {
+func (app *localClient) EndBlockAsync(ctx context.Context, req types.RequestEndBlock) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -160,10 +151,10 @@ func (app *localClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes {
 	return app.callback(
 		types.ToRequestEndBlock(req),
 		types.ToResponseEndBlock(res),
-	)
+	), nil
 }
 
-func (app *localClient) ListSnapshotsAsync(req types.RequestListSnapshots) *ReqRes {
+func (app *localClient) ListSnapshotsAsync(ctx context.Context, req types.RequestListSnapshots) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -171,10 +162,10 @@ func (app *localClient) ListSnapshotsAsync(req types.RequestListSnapshots) *ReqR
 	return app.callback(
 		types.ToRequestListSnapshots(req),
 		types.ToResponseListSnapshots(res),
-	)
+	), nil
 }
 
-func (app *localClient) OfferSnapshotAsync(req types.RequestOfferSnapshot) *ReqRes {
+func (app *localClient) OfferSnapshotAsync(ctx context.Context, req types.RequestOfferSnapshot) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -182,10 +173,13 @@ func (app *localClient) OfferSnapshotAsync(req types.RequestOfferSnapshot) *ReqR
 	return app.callback(
 		types.ToRequestOfferSnapshot(req),
 		types.ToResponseOfferSnapshot(res),
-	)
+	), nil
 }
 
-func (app *localClient) LoadSnapshotChunkAsync(req types.RequestLoadSnapshotChunk) *ReqRes {
+func (app *localClient) LoadSnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestLoadSnapshotChunk,
+) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -193,10 +187,13 @@ func (app *localClient) LoadSnapshotChunkAsync(req types.RequestLoadSnapshotChun
 	return app.callback(
 		types.ToRequestLoadSnapshotChunk(req),
 		types.ToResponseLoadSnapshotChunk(res),
-	)
+	), nil
 }
 
-func (app *localClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotChunk) *ReqRes {
+func (app *localClient) ApplySnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestApplySnapshotChunk,
+) (*ReqRes, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -204,36 +201,32 @@ func (app *localClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotCh
 	return app.callback(
 		types.ToRequestApplySnapshotChunk(req),
 		types.ToResponseApplySnapshotChunk(res),
-	)
+	), nil
 }
 
 //-------------------------------------------------------
 
-func (app *localClient) FlushSync() error {
+func (app *localClient) FlushSync(ctx context.Context) error {
 	return nil
 }
 
-func (app *localClient) EchoSync(msg string) (*types.ResponseEcho, error) {
+func (app *localClient) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
 	return &types.ResponseEcho{Message: msg}, nil
 }
 
-func (app *localClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+func (app *localClient) InfoSync(ctx context.Context, req types.RequestInfo) (*types.ResponseInfo, error) {
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Info(req)
 	return &res, nil
 }
 
-func (app *localClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+func (app *localClient) DeliverTxSync(
+	ctx context.Context,
+	req types.RequestDeliverTx,
+) (*types.ResponseDeliverTx, error) {
 
-	res := app.Application.SetOption(req)
-	return &res, nil
-}
-
-func (app *localClient) DeliverTxSync(req types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -241,7 +234,10 @@ func (app *localClient) DeliverTxSync(req types.RequestDeliverTx) (*types.Respon
 	return &res, nil
 }
 
-func (app *localClient) CheckTxSync(req types.RequestCheckTx) (*types.ResponseCheckTx, error) {
+func (app *localClient) CheckTxSync(
+	ctx context.Context,
+	req types.RequestCheckTx,
+) (*types.ResponseCheckTx, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -249,15 +245,18 @@ func (app *localClient) CheckTxSync(req types.RequestCheckTx) (*types.ResponseCh
 	return &res, nil
 }
 
-func (app *localClient) QuerySync(req types.RequestQuery) (*types.ResponseQuery, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+func (app *localClient) QuerySync(
+	ctx context.Context,
+	req types.RequestQuery,
+) (*types.ResponseQuery, error) {
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Query(req)
 	return &res, nil
 }
 
-func (app *localClient) CommitSync() (*types.ResponseCommit, error) {
+func (app *localClient) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -265,7 +264,11 @@ func (app *localClient) CommitSync() (*types.ResponseCommit, error) {
 	return &res, nil
 }
 
-func (app *localClient) InitChainSync(req types.RequestInitChain) (*types.ResponseInitChain, error) {
+func (app *localClient) InitChainSync(
+	ctx context.Context,
+	req types.RequestInitChain,
+) (*types.ResponseInitChain, error) {
+
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -273,7 +276,11 @@ func (app *localClient) InitChainSync(req types.RequestInitChain) (*types.Respon
 	return &res, nil
 }
 
-func (app *localClient) BeginBlockSync(req types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
+func (app *localClient) BeginBlockSync(
+	ctx context.Context,
+	req types.RequestBeginBlock,
+) (*types.ResponseBeginBlock, error) {
+
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -281,7 +288,11 @@ func (app *localClient) BeginBlockSync(req types.RequestBeginBlock) (*types.Resp
 	return &res, nil
 }
 
-func (app *localClient) EndBlockSync(req types.RequestEndBlock) (*types.ResponseEndBlock, error) {
+func (app *localClient) EndBlockSync(
+	ctx context.Context,
+	req types.RequestEndBlock,
+) (*types.ResponseEndBlock, error) {
+
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -289,7 +300,11 @@ func (app *localClient) EndBlockSync(req types.RequestEndBlock) (*types.Response
 	return &res, nil
 }
 
-func (app *localClient) ListSnapshotsSync(req types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
+func (app *localClient) ListSnapshotsSync(
+	ctx context.Context,
+	req types.RequestListSnapshots,
+) (*types.ResponseListSnapshots, error) {
+
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -297,7 +312,11 @@ func (app *localClient) ListSnapshotsSync(req types.RequestListSnapshots) (*type
 	return &res, nil
 }
 
-func (app *localClient) OfferSnapshotSync(req types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
+func (app *localClient) OfferSnapshotSync(
+	ctx context.Context,
+	req types.RequestOfferSnapshot,
+) (*types.ResponseOfferSnapshot, error) {
+
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -306,7 +325,9 @@ func (app *localClient) OfferSnapshotSync(req types.RequestOfferSnapshot) (*type
 }
 
 func (app *localClient) LoadSnapshotChunkSync(
+	ctx context.Context,
 	req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
+
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -315,7 +336,9 @@ func (app *localClient) LoadSnapshotChunkSync(
 }
 
 func (app *localClient) ApplySnapshotChunkSync(
+	ctx context.Context,
 	req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
+
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
 
@@ -327,13 +350,12 @@ func (app *localClient) ApplySnapshotChunkSync(
 
 func (app *localClient) callback(req *types.Request, res *types.Response) *ReqRes {
 	app.Callback(req, res)
-	rr := newLocalReqRes(req, res)
-	rr.callbackInvoked = true
-	return rr
+	return newLocalReqRes(req, res)
 }
 
 func newLocalReqRes(req *types.Request, res *types.Response) *ReqRes {
 	reqRes := NewReqRes(req)
 	reqRes.Response = res
+	reqRes.SetDone()
 	return reqRes
 }

abci/client/mocks/client.go

@@ -1,9 +1,12 @@
-// Code generated by mockery v1.1.1. DO NOT EDIT.
+// Code generated by mockery v2.5.1. DO NOT EDIT.
 
 package mocks
 
 import (
+	context "context"
+
 	abcicli "github.com/tendermint/tendermint/abci/client"
+
 	log "github.com/tendermint/tendermint/libs/log"
 
 	mock "github.com/stretchr/testify/mock"
@@ -16,29 +19,36 @@ type Client struct {
 	mock.Mock
 }
 
-// ApplySnapshotChunkAsync provides a mock function with given fields: _a0
-func (_m *Client) ApplySnapshotChunkAsync(_a0 types.RequestApplySnapshotChunk) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// ApplySnapshotChunkAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ApplySnapshotChunkAsync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestApplySnapshotChunk) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// ApplySnapshotChunkSync provides a mock function with given fields: _a0
-func (_m *Client) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
-	ret := _m.Called(_a0)
+// ApplySnapshotChunkSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ApplySnapshotChunkSync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseApplySnapshotChunk
-	if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) *types.ResponseApplySnapshotChunk); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *types.ResponseApplySnapshotChunk); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseApplySnapshotChunk)
@@ -46,8 +56,8 @@ func (_m *Client) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (*
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestApplySnapshotChunk) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestApplySnapshotChunk) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -55,29 +65,36 @@ func (_m *Client) ApplySnapshotChunkSync(_a0 types.RequestApplySnapshotChunk) (*
 	return r0, r1
 }
 
-// BeginBlockAsync provides a mock function with given fields: _a0
-func (_m *Client) BeginBlockAsync(_a0 types.RequestBeginBlock) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// BeginBlockAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) BeginBlockAsync(_a0 context.Context, _a1 types.RequestBeginBlock) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestBeginBlock) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// BeginBlockSync provides a mock function with given fields: _a0
-func (_m *Client) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
-	ret := _m.Called(_a0)
+// BeginBlockSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) BeginBlockSync(_a0 context.Context, _a1 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseBeginBlock
-	if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) *types.ResponseBeginBlock); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *types.ResponseBeginBlock); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseBeginBlock)
@@ -85,8 +102,8 @@ func (_m *Client) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBe
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestBeginBlock) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestBeginBlock) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -94,29 +111,36 @@ func (_m *Client) BeginBlockSync(_a0 types.RequestBeginBlock) (*types.ResponseBe
 	return r0, r1
 }
 
-// CheckTxAsync provides a mock function with given fields: _a0
-func (_m *Client) CheckTxAsync(_a0 types.RequestCheckTx) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// CheckTxAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestCheckTx) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// CheckTxSync provides a mock function with given fields: _a0
-func (_m *Client) CheckTxSync(_a0 types.RequestCheckTx) (*types.ResponseCheckTx, error) {
-	ret := _m.Called(_a0)
+// CheckTxSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) CheckTxSync(_a0 context.Context, _a1 types.RequestCheckTx) (*types.ResponseCheckTx, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseCheckTx
-	if rf, ok := ret.Get(0).(func(types.RequestCheckTx) *types.ResponseCheckTx); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *types.ResponseCheckTx); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseCheckTx)
@@ -124,7 +148,30 @@ func (_m *Client) CheckTxSync(_a0 types.RequestCheckTx) (*types.ResponseCheckTx,
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestCheckTx) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestCheckTx) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CommitAsync provides a mock function with given fields: _a0
+func (_m *Client) CommitAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context) *abcicli.ReqRes); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abcicli.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
 		r1 = rf(_a0)
 	} else {
 		r1 = ret.Error(1)
@@ -133,29 +180,13 @@ func (_m *Client) CheckTxSync(_a0 types.RequestCheckTx) (*types.ResponseCheckTx,
 	return r0, r1
 }
 
-// CommitAsync provides a mock function with given fields:
-func (_m *Client) CommitAsync() *abcicli.ReqRes {
-	ret := _m.Called()
-
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abcicli.ReqRes)
-		}
-	}
-
-	return r0
-}
-
-// CommitSync provides a mock function with given fields:
-func (_m *Client) CommitSync() (*types.ResponseCommit, error) {
-	ret := _m.Called()
+// CommitSync provides a mock function with given fields: _a0
+func (_m *Client) CommitSync(_a0 context.Context) (*types.ResponseCommit, error) {
+	ret := _m.Called(_a0)
 
 	var r0 *types.ResponseCommit
-	if rf, ok := ret.Get(0).(func() *types.ResponseCommit); ok {
-		r0 = rf()
+	if rf, ok := ret.Get(0).(func(context.Context) *types.ResponseCommit); ok {
+		r0 = rf(_a0)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseCommit)
@@ -163,8 +194,8 @@ func (_m *Client) CommitSync() (*types.ResponseCommit, error) {
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func() error); ok {
-		r1 = rf()
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(_a0)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -172,29 +203,36 @@ func (_m *Client) CommitSync() (*types.ResponseCommit, error) {
 	return r0, r1
 }
 
-// DeliverTxAsync provides a mock function with given fields: _a0
-func (_m *Client) DeliverTxAsync(_a0 types.RequestDeliverTx) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// DeliverTxAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestDeliverTx) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// DeliverTxSync provides a mock function with given fields: _a0
-func (_m *Client) DeliverTxSync(_a0 types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
-	ret := _m.Called(_a0)
+// DeliverTxSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) DeliverTxSync(_a0 context.Context, _a1 types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseDeliverTx
-	if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) *types.ResponseDeliverTx); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *types.ResponseDeliverTx); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseDeliverTx)
@@ -202,8 +240,8 @@ func (_m *Client) DeliverTxSync(_a0 types.RequestDeliverTx) (*types.ResponseDeli
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestDeliverTx) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestDeliverTx) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -211,29 +249,36 @@ func (_m *Client) DeliverTxSync(_a0 types.RequestDeliverTx) (*types.ResponseDeli
 	return r0, r1
 }
 
-// EchoAsync provides a mock function with given fields: msg
-func (_m *Client) EchoAsync(msg string) *abcicli.ReqRes {
-	ret := _m.Called(msg)
+// EchoAsync provides a mock function with given fields: ctx, msg
+func (_m *Client) EchoAsync(ctx context.Context, msg string) (*abcicli.ReqRes, error) {
+	ret := _m.Called(ctx, msg)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(string) *abcicli.ReqRes); ok {
-		r0 = rf(msg)
+	if rf, ok := ret.Get(0).(func(context.Context, string) *abcicli.ReqRes); ok {
+		r0 = rf(ctx, msg)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+		r1 = rf(ctx, msg)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// EchoSync provides a mock function with given fields: msg
-func (_m *Client) EchoSync(msg string) (*types.ResponseEcho, error) {
-	ret := _m.Called(msg)
+// EchoSync provides a mock function with given fields: ctx, msg
+func (_m *Client) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+	ret := _m.Called(ctx, msg)
 
 	var r0 *types.ResponseEcho
-	if rf, ok := ret.Get(0).(func(string) *types.ResponseEcho); ok {
-		r0 = rf(msg)
+	if rf, ok := ret.Get(0).(func(context.Context, string) *types.ResponseEcho); ok {
+		r0 = rf(ctx, msg)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseEcho)
@@ -241,8 +286,8 @@ func (_m *Client) EchoSync(msg string) (*types.ResponseEcho, error) {
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(string) error); ok {
-		r1 = rf(msg)
+	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+		r1 = rf(ctx, msg)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -250,29 +295,36 @@ func (_m *Client) EchoSync(msg string) (*types.ResponseEcho, error) {
 	return r0, r1
 }
 
-// EndBlockAsync provides a mock function with given fields: _a0
-func (_m *Client) EndBlockAsync(_a0 types.RequestEndBlock) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// EndBlockAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) EndBlockAsync(_a0 context.Context, _a1 types.RequestEndBlock) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestEndBlock) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// EndBlockSync provides a mock function with given fields: _a0
-func (_m *Client) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlock, error) {
-	ret := _m.Called(_a0)
+// EndBlockSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) EndBlockSync(_a0 context.Context, _a1 types.RequestEndBlock) (*types.ResponseEndBlock, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseEndBlock
-	if rf, ok := ret.Get(0).(func(types.RequestEndBlock) *types.ResponseEndBlock); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *types.ResponseEndBlock); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseEndBlock)
@@ -280,8 +332,8 @@ func (_m *Client) EndBlockSync(_a0 types.RequestEndBlock) (*types.ResponseEndBlo
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestEndBlock) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestEndBlock) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -303,42 +355,12 @@ func (_m *Client) Error() error {
 	return r0
 }
 
-// FlushAsync provides a mock function with given fields:
-func (_m *Client) FlushAsync() *abcicli.ReqRes {
-	ret := _m.Called()
-
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func() *abcicli.ReqRes); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abcicli.ReqRes)
-		}
-	}
-
-	return r0
-}
-
-// FlushSync provides a mock function with given fields:
-func (_m *Client) FlushSync() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// InfoAsync provides a mock function with given fields: _a0
-func (_m *Client) InfoAsync(_a0 types.RequestInfo) *abcicli.ReqRes {
+// FlushAsync provides a mock function with given fields: _a0
+func (_m *Client) FlushAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestInfo) *abcicli.ReqRes); ok {
+	if rf, ok := ret.Get(0).(func(context.Context) *abcicli.ReqRes); ok {
 		r0 = rf(_a0)
 	} else {
 		if ret.Get(0) != nil {
@@ -346,24 +368,8 @@ func (_m *Client) InfoAsync(_a0 types.RequestInfo) *abcicli.ReqRes {
 		}
 	}
 
-	return r0
-}
-
-// InfoSync provides a mock function with given fields: _a0
-func (_m *Client) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *types.ResponseInfo
-	if rf, ok := ret.Get(0).(func(types.RequestInfo) *types.ResponseInfo); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseInfo)
-		}
-	}
-
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestInfo) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
 		r1 = rf(_a0)
 	} else {
 		r1 = ret.Error(1)
@@ -372,29 +378,96 @@ func (_m *Client) InfoSync(_a0 types.RequestInfo) (*types.ResponseInfo, error) {
 	return r0, r1
 }
 
-// InitChainAsync provides a mock function with given fields: _a0
-func (_m *Client) InitChainAsync(_a0 types.RequestInitChain) *abcicli.ReqRes {
+// FlushSync provides a mock function with given fields: _a0
+func (_m *Client) FlushSync(_a0 context.Context) error {
 	ret := _m.Called(_a0)
 
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestInitChain) *abcicli.ReqRes); ok {
+	var r0 error
+	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
 		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// InfoAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InfoAsync(_a0 context.Context, _a1 types.RequestInfo) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestInfo) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// InitChainSync provides a mock function with given fields: _a0
-func (_m *Client) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInitChain, error) {
-	ret := _m.Called(_a0)
+// InfoSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InfoSync(_a0 context.Context, _a1 types.RequestInfo) (*types.ResponseInfo, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *types.ResponseInfo
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *types.ResponseInfo); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseInfo)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestInfo) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InitChainAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InitChainAsync(_a0 context.Context, _a1 types.RequestInitChain) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abcicli.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestInitChain) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InitChainSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InitChainSync(_a0 context.Context, _a1 types.RequestInitChain) (*types.ResponseInitChain, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseInitChain
-	if rf, ok := ret.Get(0).(func(types.RequestInitChain) *types.ResponseInitChain); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *types.ResponseInitChain); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseInitChain)
@@ -402,8 +475,8 @@ func (_m *Client) InitChainSync(_a0 types.RequestInitChain) (*types.ResponseInit
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestInitChain) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestInitChain) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -425,29 +498,36 @@ func (_m *Client) IsRunning() bool {
 	return r0
 }
 
-// ListSnapshotsAsync provides a mock function with given fields: _a0
-func (_m *Client) ListSnapshotsAsync(_a0 types.RequestListSnapshots) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// ListSnapshotsAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ListSnapshotsAsync(_a0 context.Context, _a1 types.RequestListSnapshots) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestListSnapshots) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// ListSnapshotsSync provides a mock function with given fields: _a0
-func (_m *Client) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
-	ret := _m.Called(_a0)
+// ListSnapshotsSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ListSnapshotsSync(_a0 context.Context, _a1 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseListSnapshots
-	if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) *types.ResponseListSnapshots); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *types.ResponseListSnapshots); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseListSnapshots)
@@ -455,8 +535,8 @@ func (_m *Client) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.Resp
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestListSnapshots) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestListSnapshots) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -464,29 +544,36 @@ func (_m *Client) ListSnapshotsSync(_a0 types.RequestListSnapshots) (*types.Resp
 	return r0, r1
 }
 
-// LoadSnapshotChunkAsync provides a mock function with given fields: _a0
-func (_m *Client) LoadSnapshotChunkAsync(_a0 types.RequestLoadSnapshotChunk) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// LoadSnapshotChunkAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) LoadSnapshotChunkAsync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestLoadSnapshotChunk) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// LoadSnapshotChunkSync provides a mock function with given fields: _a0
-func (_m *Client) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
-	ret := _m.Called(_a0)
+// LoadSnapshotChunkSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) LoadSnapshotChunkSync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseLoadSnapshotChunk
-	if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) *types.ResponseLoadSnapshotChunk); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *types.ResponseLoadSnapshotChunk); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseLoadSnapshotChunk)
@@ -494,8 +581,8 @@ func (_m *Client) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*ty
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestLoadSnapshotChunk) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestLoadSnapshotChunk) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -503,29 +590,36 @@ func (_m *Client) LoadSnapshotChunkSync(_a0 types.RequestLoadSnapshotChunk) (*ty
 	return r0, r1
 }
 
-// OfferSnapshotAsync provides a mock function with given fields: _a0
-func (_m *Client) OfferSnapshotAsync(_a0 types.RequestOfferSnapshot) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// OfferSnapshotAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) OfferSnapshotAsync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestOfferSnapshot) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// OfferSnapshotSync provides a mock function with given fields: _a0
-func (_m *Client) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
-	ret := _m.Called(_a0)
+// OfferSnapshotSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) OfferSnapshotSync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseOfferSnapshot
-	if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) *types.ResponseOfferSnapshot); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *types.ResponseOfferSnapshot); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseOfferSnapshot)
@@ -533,8 +627,8 @@ func (_m *Client) OfferSnapshotSync(_a0 types.RequestOfferSnapshot) (*types.Resp
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestOfferSnapshot) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestOfferSnapshot) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -575,29 +669,36 @@ func (_m *Client) OnStop() {
 	_m.Called()
 }
 
-// QueryAsync provides a mock function with given fields: _a0
-func (_m *Client) QueryAsync(_a0 types.RequestQuery) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
+// QueryAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) QueryAsync(_a0 context.Context, _a1 types.RequestQuery) (*abcicli.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestQuery) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *abcicli.ReqRes); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
-	return r0
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestQuery) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
 }
 
-// QuerySync provides a mock function with given fields: _a0
-func (_m *Client) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error) {
-	ret := _m.Called(_a0)
+// QuerySync provides a mock function with given fields: _a0, _a1
+func (_m *Client) QuerySync(_a0 context.Context, _a1 types.RequestQuery) (*types.ResponseQuery, error) {
+	ret := _m.Called(_a0, _a1)
 
 	var r0 *types.ResponseQuery
-	if rf, ok := ret.Get(0).(func(types.RequestQuery) *types.ResponseQuery); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *types.ResponseQuery); ok {
+		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*types.ResponseQuery)
@@ -605,8 +706,8 @@ func (_m *Client) QuerySync(_a0 types.RequestQuery) (*types.ResponseQuery, error
 	}
 
 	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestQuery) error); ok {
-		r1 = rf(_a0)
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestQuery) error); ok {
+		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -649,45 +750,6 @@ func (_m *Client) SetLogger(_a0 log.Logger) {
 	_m.Called(_a0)
 }
 
-// SetOptionAsync provides a mock function with given fields: _a0
-func (_m *Client) SetOptionAsync(_a0 types.RequestSetOption) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
-
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestSetOption) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abcicli.ReqRes)
-		}
-	}
-
-	return r0
-}
-
-// SetOptionSync provides a mock function with given fields: _a0
-func (_m *Client) SetOptionSync(_a0 types.RequestSetOption) (*types.ResponseSetOption, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *types.ResponseSetOption
-	if rf, ok := ret.Get(0).(func(types.RequestSetOption) *types.ResponseSetOption); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseSetOption)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestSetOption) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
 // SetResponseCallback provides a mock function with given fields: _a0
 func (_m *Client) SetResponseCallback(_a0 abcicli.Callback) {
 	_m.Called(_a0)

abci/client/socket_client.go

@@ -3,6 +3,7 @@ package abcicli
 import (
 	"bufio"
 	"container/list"
+	"context"
 	"errors"
 	"fmt"
 	"io"
@@ -18,10 +19,18 @@ import (
 )
 
 const (
-	reqQueueSize    = 256 // TODO make configurable
-	flushThrottleMS = 20  // Don't wait longer than...
+	// reqQueueSize is the max number of queued async requests.
+	// (memory: 256MB max assuming 1MB transactions)
+	reqQueueSize = 256
+	// Don't wait longer than...
+	flushThrottleMS = 20
 )
 
+type reqResWithContext struct {
+	R *ReqRes
+	C context.Context // if context.Err is not nil, reqRes will be thrown away (ignored)
+}
+
 // This is goroutine-safe, but users should beware that the application in
 // general is not meant to be interfaced with concurrent callers.
 type socketClient struct {
@@ -31,10 +40,10 @@ type socketClient struct {
 	mustConnect bool
 	conn        net.Conn
 
-	reqQueue   chan *ReqRes
+	reqQueue   chan *reqResWithContext
 	flushTimer *timer.ThrottleTimer
 
-	mtx     tmsync.Mutex
+	mtx     tmsync.RWMutex
 	err     error
 	reqSent *list.List                            // list of requests sent, waiting for response
 	resCb   func(*types.Request, *types.Response) // called on all requests, if set.
@@ -47,7 +56,7 @@ var _ Client = (*socketClient)(nil)
 // if it fails to connect.
 func NewSocketClient(addr string, mustConnect bool) Client {
 	cli := &socketClient{
-		reqQueue:    make(chan *ReqRes, reqQueueSize),
+		reqQueue:    make(chan *reqResWithContext, reqQueueSize),
 		flushTimer:  timer.NewThrottleTimer("socketClient", flushThrottleMS),
 		mustConnect: mustConnect,
 
@@ -99,8 +108,8 @@ func (cli *socketClient) OnStop() {
 
 // Error returns an error if the client was stopped abruptly.
 func (cli *socketClient) Error() error {
-	cli.mtx.Lock()
-	defer cli.mtx.Unlock()
+	cli.mtx.RLock()
+	defer cli.mtx.RUnlock()
 	return cli.err
 }
 
@@ -110,8 +119,8 @@ func (cli *socketClient) Error() error {
 // NOTE: callback may get internally generated flush responses.
 func (cli *socketClient) SetResponseCallback(resCb Callback) {
 	cli.mtx.Lock()
+	defer cli.mtx.Unlock()
 	cli.resCb = resCb
-	cli.mtx.Unlock()
 }
 
 //----------------------------------------
@@ -123,15 +132,20 @@ func (cli *socketClient) sendRequestsRoutine(conn io.Writer) {
 		case reqres := <-cli.reqQueue:
 			// cli.Logger.Debug("Sent request", "requestType", reflect.TypeOf(reqres.Request), "request", reqres.Request)
 
-			cli.willSendReq(reqres)
-			err := types.WriteMessage(reqres.Request, w)
+			if reqres.C.Err() != nil {
+				cli.Logger.Debug("Request's context is done", "req", reqres.R, "err", reqres.C.Err())
+				continue
+			}
+
+			cli.willSendReq(reqres.R)
+			err := types.WriteMessage(reqres.R.Request, w)
 			if err != nil {
 				cli.stopForError(fmt.Errorf("write to buffer: %w", err))
 				return
 			}
 
 			// If it's a flush request, flush the current buffer.
-			if _, ok := reqres.Request.Value.(*types.Request_Flush); ok {
+			if _, ok := reqres.R.Request.Value.(*types.Request_Flush); ok {
 				err = w.Flush()
 				if err != nil {
 					cli.stopForError(fmt.Errorf("flush buffer: %w", err))
@@ -140,7 +154,7 @@ func (cli *socketClient) sendRequestsRoutine(conn io.Writer) {
 			}
 		case <-cli.flushTimer.Ch: // flush queue
 			select {
-			case cli.reqQueue <- NewReqRes(types.ToRequestFlush()):
+			case cli.reqQueue <- &reqResWithContext{R: NewReqRes(types.ToRequestFlush()), C: context.Background()}:
 			default:
 				// Probably will fill the buffer, or retry later.
 			}
@@ -219,211 +233,264 @@ func (cli *socketClient) didRecvResponse(res *types.Response) error {
 
 //----------------------------------------
 
-func (cli *socketClient) EchoAsync(msg string) *ReqRes {
-	return cli.queueRequest(types.ToRequestEcho(msg))
+func (cli *socketClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestEcho(msg))
 }
 
-func (cli *socketClient) FlushAsync() *ReqRes {
-	return cli.queueRequest(types.ToRequestFlush())
+func (cli *socketClient) FlushAsync(ctx context.Context) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestFlush())
 }
 
-func (cli *socketClient) InfoAsync(req types.RequestInfo) *ReqRes {
-	return cli.queueRequest(types.ToRequestInfo(req))
+func (cli *socketClient) InfoAsync(ctx context.Context, req types.RequestInfo) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestInfo(req))
 }
 
-func (cli *socketClient) SetOptionAsync(req types.RequestSetOption) *ReqRes {
-	return cli.queueRequest(types.ToRequestSetOption(req))
+func (cli *socketClient) DeliverTxAsync(ctx context.Context, req types.RequestDeliverTx) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestDeliverTx(req))
 }
 
-func (cli *socketClient) DeliverTxAsync(req types.RequestDeliverTx) *ReqRes {
-	return cli.queueRequest(types.ToRequestDeliverTx(req))
+func (cli *socketClient) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestCheckTx(req))
 }
 
-func (cli *socketClient) CheckTxAsync(req types.RequestCheckTx) *ReqRes {
-	return cli.queueRequest(types.ToRequestCheckTx(req))
+func (cli *socketClient) QueryAsync(ctx context.Context, req types.RequestQuery) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestQuery(req))
 }
 
-func (cli *socketClient) QueryAsync(req types.RequestQuery) *ReqRes {
-	return cli.queueRequest(types.ToRequestQuery(req))
+func (cli *socketClient) CommitAsync(ctx context.Context) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestCommit())
 }
 
-func (cli *socketClient) CommitAsync() *ReqRes {
-	return cli.queueRequest(types.ToRequestCommit())
+func (cli *socketClient) InitChainAsync(ctx context.Context, req types.RequestInitChain) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestInitChain(req))
 }
 
-func (cli *socketClient) InitChainAsync(req types.RequestInitChain) *ReqRes {
-	return cli.queueRequest(types.ToRequestInitChain(req))
+func (cli *socketClient) BeginBlockAsync(ctx context.Context, req types.RequestBeginBlock) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestBeginBlock(req))
 }
 
-func (cli *socketClient) BeginBlockAsync(req types.RequestBeginBlock) *ReqRes {
-	return cli.queueRequest(types.ToRequestBeginBlock(req))
+func (cli *socketClient) EndBlockAsync(ctx context.Context, req types.RequestEndBlock) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestEndBlock(req))
 }
 
-func (cli *socketClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes {
-	return cli.queueRequest(types.ToRequestEndBlock(req))
+func (cli *socketClient) ListSnapshotsAsync(ctx context.Context, req types.RequestListSnapshots) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestListSnapshots(req))
 }
 
-func (cli *socketClient) ListSnapshotsAsync(req types.RequestListSnapshots) *ReqRes {
-	return cli.queueRequest(types.ToRequestListSnapshots(req))
+func (cli *socketClient) OfferSnapshotAsync(ctx context.Context, req types.RequestOfferSnapshot) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestOfferSnapshot(req))
 }
 
-func (cli *socketClient) OfferSnapshotAsync(req types.RequestOfferSnapshot) *ReqRes {
-	return cli.queueRequest(types.ToRequestOfferSnapshot(req))
+func (cli *socketClient) LoadSnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestLoadSnapshotChunk,
+) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestLoadSnapshotChunk(req))
 }
 
-func (cli *socketClient) LoadSnapshotChunkAsync(req types.RequestLoadSnapshotChunk) *ReqRes {
-	return cli.queueRequest(types.ToRequestLoadSnapshotChunk(req))
-}
-
-func (cli *socketClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotChunk) *ReqRes {
-	return cli.queueRequest(types.ToRequestApplySnapshotChunk(req))
+func (cli *socketClient) ApplySnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestApplySnapshotChunk,
+) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestApplySnapshotChunk(req))
 }
 
 //----------------------------------------
 
-func (cli *socketClient) FlushSync() error {
-	reqRes := cli.queueRequest(types.ToRequestFlush())
+func (cli *socketClient) FlushSync(ctx context.Context) error {
+	reqRes, err := cli.queueRequest(ctx, types.ToRequestFlush(), true)
+	if err != nil {
+		return queueErr(err)
+	}
+
 	if err := cli.Error(); err != nil {
 		return err
 	}
-	reqRes.Wait() // NOTE: if we don't flush the queue, its possible to get stuck here
-	return cli.Error()
+
+	gotResp := make(chan struct{})
+	go func() {
+		// NOTE: if we don't flush the queue, its possible to get stuck here
+		reqRes.Wait()
+		close(gotResp)
+	}()
+
+	select {
+	case <-gotResp:
+		return cli.Error()
+	case <-ctx.Done():
+		return ctx.Err()
+	}
 }
 
-func (cli *socketClient) EchoSync(msg string) (*types.ResponseEcho, error) {
-	reqres := cli.queueRequest(types.ToRequestEcho(msg))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestEcho(msg))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetEcho(), cli.Error()
+	return reqres.Response.GetEcho(), nil
 }
 
-func (cli *socketClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, error) {
-	reqres := cli.queueRequest(types.ToRequestInfo(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) InfoSync(
+	ctx context.Context,
+	req types.RequestInfo,
+) (*types.ResponseInfo, error) {
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestInfo(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetInfo(), cli.Error()
+	return reqres.Response.GetInfo(), nil
 }
 
-func (cli *socketClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
-	reqres := cli.queueRequest(types.ToRequestSetOption(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) DeliverTxSync(
+	ctx context.Context,
+	req types.RequestDeliverTx,
+) (*types.ResponseDeliverTx, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestDeliverTx(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetSetOption(), cli.Error()
+	return reqres.Response.GetDeliverTx(), nil
 }
 
-func (cli *socketClient) DeliverTxSync(req types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
-	reqres := cli.queueRequest(types.ToRequestDeliverTx(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) CheckTxSync(
+	ctx context.Context,
+	req types.RequestCheckTx,
+) (*types.ResponseCheckTx, error) {
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestCheckTx(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetDeliverTx(), cli.Error()
+	return reqres.Response.GetCheckTx(), nil
 }
 
-func (cli *socketClient) CheckTxSync(req types.RequestCheckTx) (*types.ResponseCheckTx, error) {
-	reqres := cli.queueRequest(types.ToRequestCheckTx(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) QuerySync(
+	ctx context.Context,
+	req types.RequestQuery,
+) (*types.ResponseQuery, error) {
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestQuery(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetCheckTx(), cli.Error()
+	return reqres.Response.GetQuery(), nil
 }
 
-func (cli *socketClient) QuerySync(req types.RequestQuery) (*types.ResponseQuery, error) {
-	reqres := cli.queueRequest(types.ToRequestQuery(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestCommit())
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetQuery(), cli.Error()
+	return reqres.Response.GetCommit(), nil
 }
 
-func (cli *socketClient) CommitSync() (*types.ResponseCommit, error) {
-	reqres := cli.queueRequest(types.ToRequestCommit())
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) InitChainSync(
+	ctx context.Context,
+	req types.RequestInitChain,
+) (*types.ResponseInitChain, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestInitChain(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetCommit(), cli.Error()
+	return reqres.Response.GetInitChain(), nil
 }
 
-func (cli *socketClient) InitChainSync(req types.RequestInitChain) (*types.ResponseInitChain, error) {
-	reqres := cli.queueRequest(types.ToRequestInitChain(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) BeginBlockSync(
+	ctx context.Context,
+	req types.RequestBeginBlock,
+) (*types.ResponseBeginBlock, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestBeginBlock(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetInitChain(), cli.Error()
+	return reqres.Response.GetBeginBlock(), nil
 }
 
-func (cli *socketClient) BeginBlockSync(req types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
-	reqres := cli.queueRequest(types.ToRequestBeginBlock(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) EndBlockSync(
+	ctx context.Context,
+	req types.RequestEndBlock,
+) (*types.ResponseEndBlock, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestEndBlock(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetBeginBlock(), cli.Error()
+	return reqres.Response.GetEndBlock(), nil
 }
 
-func (cli *socketClient) EndBlockSync(req types.RequestEndBlock) (*types.ResponseEndBlock, error) {
-	reqres := cli.queueRequest(types.ToRequestEndBlock(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) ListSnapshotsSync(
+	ctx context.Context,
+	req types.RequestListSnapshots,
+) (*types.ResponseListSnapshots, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestListSnapshots(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetEndBlock(), cli.Error()
+	return reqres.Response.GetListSnapshots(), nil
 }
 
-func (cli *socketClient) ListSnapshotsSync(req types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
-	reqres := cli.queueRequest(types.ToRequestListSnapshots(req))
-	if err := cli.FlushSync(); err != nil {
+func (cli *socketClient) OfferSnapshotSync(
+	ctx context.Context,
+	req types.RequestOfferSnapshot,
+) (*types.ResponseOfferSnapshot, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestOfferSnapshot(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetListSnapshots(), cli.Error()
-}
-
-func (cli *socketClient) OfferSnapshotSync(req types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
-	reqres := cli.queueRequest(types.ToRequestOfferSnapshot(req))
-	if err := cli.FlushSync(); err != nil {
-		return nil, err
-	}
-
-	return reqres.Response.GetOfferSnapshot(), cli.Error()
+	return reqres.Response.GetOfferSnapshot(), nil
 }
 
 func (cli *socketClient) LoadSnapshotChunkSync(
+	ctx context.Context,
 	req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
-	reqres := cli.queueRequest(types.ToRequestLoadSnapshotChunk(req))
-	if err := cli.FlushSync(); err != nil {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestLoadSnapshotChunk(req))
+	if err != nil {
 		return nil, err
 	}
-
-	return reqres.Response.GetLoadSnapshotChunk(), cli.Error()
+	return reqres.Response.GetLoadSnapshotChunk(), nil
 }
 
 func (cli *socketClient) ApplySnapshotChunkSync(
+	ctx context.Context,
 	req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
-	reqres := cli.queueRequest(types.ToRequestApplySnapshotChunk(req))
-	if err := cli.FlushSync(); err != nil {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestApplySnapshotChunk(req))
+	if err != nil {
 		return nil, err
 	}
-	return reqres.Response.GetApplySnapshotChunk(), cli.Error()
+	return reqres.Response.GetApplySnapshotChunk(), nil
 }
 
 //----------------------------------------
 
-func (cli *socketClient) queueRequest(req *types.Request) *ReqRes {
+// queueRequest enqueues req onto the queue. If the queue is full, it ether
+// returns an error (sync=false) or blocks (sync=true).
+//
+// When sync=true, ctx can be used to break early. When sync=false, ctx will be
+// used later to determine if request should be dropped (if ctx.Err is
+// non-nil).
+//
+// The caller is responsible for checking cli.Error.
+func (cli *socketClient) queueRequest(ctx context.Context, req *types.Request, sync bool) (*ReqRes, error) {
 	reqres := NewReqRes(req)
 
-	// TODO: set cli.err if reqQueue times out
-	cli.reqQueue <- reqres
+	if sync {
+		select {
+		case cli.reqQueue <- &reqResWithContext{R: reqres, C: context.Background()}:
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		}
+	} else {
+		select {
+		case cli.reqQueue <- &reqResWithContext{R: reqres, C: ctx}:
+		default:
+			return nil, errors.New("buffer is full")
+		}
+	}
 
 	// Maybe auto-flush, or unset auto-flush
 	switch req.Value.(type) {
@@ -433,7 +500,41 @@ func (cli *socketClient) queueRequest(req *types.Request) *ReqRes {
 		cli.flushTimer.Set()
 	}
 
-	return reqres
+	return reqres, nil
+}
+
+func (cli *socketClient) queueRequestAsync(
+	ctx context.Context,
+	req *types.Request,
+) (*ReqRes, error) {
+
+	reqres, err := cli.queueRequest(ctx, req, false)
+	if err != nil {
+		return nil, queueErr(err)
+	}
+
+	return reqres, cli.Error()
+}
+
+func (cli *socketClient) queueRequestAndFlushSync(
+	ctx context.Context,
+	req *types.Request,
+) (*ReqRes, error) {
+
+	reqres, err := cli.queueRequest(ctx, req, true)
+	if err != nil {
+		return nil, queueErr(err)
+	}
+
+	if err := cli.FlushSync(ctx); err != nil {
+		return nil, err
+	}
+
+	return reqres, cli.Error()
+}
+
+func queueErr(e error) error {
+	return fmt.Errorf("can't queue req: %w", e)
 }
 
 func (cli *socketClient) flushQueue() {
@@ -451,7 +552,7 @@ LOOP:
 	for {
 		select {
 		case reqres := <-cli.reqQueue:
-			reqres.Done()
+			reqres.R.Done()
 		default:
 			break LOOP
 		}
@@ -468,8 +569,6 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_Flush)
 	case *types.Request_Info:
 		_, ok = res.Value.(*types.Response_Info)
-	case *types.Request_SetOption:
-		_, ok = res.Value.(*types.Response_SetOption)
 	case *types.Request_DeliverTx:
 		_, ok = res.Value.(*types.Response_DeliverTx)
 	case *types.Request_CheckTx:
@@ -502,12 +601,10 @@ func (cli *socketClient) stopForError(err error) {
 	}
 
 	cli.mtx.Lock()
-	if cli.err == nil {
-		cli.err = err
-	}
+	cli.err = err
 	cli.mtx.Unlock()
 
-	cli.Logger.Error(fmt.Sprintf("Stopping abci.socketClient for error: %v", err.Error()))
+	cli.Logger.Info("Stopping abci.socketClient", "reason", err)
 	if err := cli.Stop(); err != nil {
 		cli.Logger.Error("Error stopping abci.socketClient", "err", err)
 	}

abci/client/socket_client_test.go

@@ -1,21 +1,24 @@
 package abcicli_test
 
 import (
+	"context"
 	"fmt"
-	"sync"
 	"testing"
 	"time"
 
+	"math/rand"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/server"
 	"github.com/tendermint/tendermint/abci/types"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
 	"github.com/tendermint/tendermint/libs/service"
 )
 
+var ctx = context.Background()
+
 func TestProperSyncCalls(t *testing.T) {
 	app := slowApp{}
 
@@ -34,11 +37,12 @@ func TestProperSyncCalls(t *testing.T) {
 	resp := make(chan error, 1)
 	go func() {
 		// This is BeginBlockSync unrolled....
-		reqres := c.BeginBlockAsync(types.RequestBeginBlock{})
-		err := c.FlushSync()
-		require.NoError(t, err)
+		reqres, err := c.BeginBlockAsync(ctx, types.RequestBeginBlock{})
+		assert.NoError(t, err)
+		err = c.FlushSync(context.Background())
+		assert.NoError(t, err)
 		res := reqres.Response.GetBeginBlock()
-		require.NotNil(t, res)
+		assert.NotNil(t, res)
 		resp <- c.Error()
 	}()
 
@@ -69,14 +73,16 @@ func TestHangingSyncCalls(t *testing.T) {
 	resp := make(chan error, 1)
 	go func() {
 		// Start BeginBlock and flush it
-		reqres := c.BeginBlockAsync(types.RequestBeginBlock{})
-		flush := c.FlushAsync()
+		reqres, err := c.BeginBlockAsync(ctx, types.RequestBeginBlock{})
+		assert.NoError(t, err)
+		flush, err := c.FlushAsync(ctx)
+		assert.NoError(t, err)
 		// wait 20 ms for all events to travel socket, but
 		// no response yet from server
 		time.Sleep(20 * time.Millisecond)
 		// kill the server, so the connections break
-		err := s.Stop()
-		require.NoError(t, err)
+		err = s.Stop()
+		assert.NoError(t, err)
 
 		// wait for the response from BeginBlock
 		reqres.Wait()
@@ -96,7 +102,7 @@ func TestHangingSyncCalls(t *testing.T) {
 func setupClientServer(t *testing.T, app types.Application) (
 	service.Service, abcicli.Client) {
 	// some port between 20k and 30k
-	port := 20000 + tmrand.Int32()%10000
+	port := 20000 + rand.Int31()%10000
 	addr := fmt.Sprintf("localhost:%d", port)
 
 	s, err := server.NewServer(addr, "socket", app)
@@ -119,71 +125,3 @@ func (slowApp) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock
 	time.Sleep(200 * time.Millisecond)
 	return types.ResponseBeginBlock{}
 }
-
-// TestCallbackInvokedWhenSetLaet ensures that the callback is invoked when
-// set after the client completes the call into the app. Currently this
-// test relies on the callback being allowed to be invoked twice if set multiple
-// times, once when set early and once when set late.
-func TestCallbackInvokedWhenSetLate(t *testing.T) {
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-	app := blockedABCIApplication{
-		wg: wg,
-	}
-	_, c := setupClientServer(t, app)
-	reqRes := c.CheckTxAsync(types.RequestCheckTx{})
-
-	done := make(chan struct{})
-	cb := func(_ *types.Response) {
-		close(done)
-	}
-	reqRes.SetCallback(cb)
-	app.wg.Done()
-	<-done
-
-	var called bool
-	cb = func(_ *types.Response) {
-		called = true
-	}
-	reqRes.SetCallback(cb)
-	require.True(t, called)
-}
-
-type blockedABCIApplication struct {
-	wg *sync.WaitGroup
-	types.BaseApplication
-}
-
-func (b blockedABCIApplication) CheckTx(r types.RequestCheckTx) types.ResponseCheckTx {
-	b.wg.Wait()
-	return b.BaseApplication.CheckTx(r)
-}
-
-// TestCallbackInvokedWhenSetEarly ensures that the callback is invoked when
-// set before the client completes the call into the app.
-func TestCallbackInvokedWhenSetEarly(t *testing.T) {
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-	app := blockedABCIApplication{
-		wg: wg,
-	}
-	_, c := setupClientServer(t, app)
-	reqRes := c.CheckTxAsync(types.RequestCheckTx{})
-
-	done := make(chan struct{})
-	cb := func(_ *types.Response) {
-		close(done)
-	}
-	reqRes.SetCallback(cb)
-	app.wg.Done()
-
-	called := func() bool {
-		select {
-		case <-done:
-			return true
-		default:
-			return false
-		}
-	}
-	require.Eventually(t, called, time.Second, time.Millisecond*25)
-}

abci/cmd/abci-cli/abci-cli.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bufio"
+	"context"
 	"encoding/hex"
 	"errors"
 	"fmt"
@@ -29,6 +30,8 @@ import (
 var (
 	client abcicli.Client
 	logger log.Logger
+
+	ctx = context.Background()
 )
 
 // flags
@@ -148,7 +151,6 @@ func addCommands() {
 	RootCmd.AddCommand(consoleCmd)
 	RootCmd.AddCommand(echoCmd)
 	RootCmd.AddCommand(infoCmd)
-	RootCmd.AddCommand(setOptionCmd)
 	RootCmd.AddCommand(deliverTxCmd)
 	RootCmd.AddCommand(checkTxCmd)
 	RootCmd.AddCommand(commitCmd)
@@ -176,7 +178,6 @@ you'd like to run:
 
 where example.file looks something like:
 
-    set_option serial on
     check_tx 0x00
     check_tx 0xff
     deliver_tx 0x00
@@ -198,7 +199,7 @@ This command opens an interactive console for running any of the other commands
 without opening a new connection each time
 `,
 	Args:      cobra.ExactArgs(0),
-	ValidArgs: []string{"echo", "info", "set_option", "deliver_tx", "check_tx", "commit", "query"},
+	ValidArgs: []string{"echo", "info", "deliver_tx", "check_tx", "commit", "query"},
 	RunE:      cmdConsole,
 }
 
@@ -216,13 +217,6 @@ var infoCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(0),
 	RunE:  cmdInfo,
 }
-var setOptionCmd = &cobra.Command{
-	Use:   "set_option",
-	Short: "set an option on the application",
-	Long:  "set an option on the application",
-	Args:  cobra.ExactArgs(2),
-	RunE:  cmdSetOption,
-}
 
 var deliverTxCmd = &cobra.Command{
 	Use:   "deliver_tx",
@@ -324,7 +318,6 @@ func cmdTest(cmd *cobra.Command, args []string) error {
 	return compose(
 		[]func() error{
 			func() error { return servertest.InitChain(client) },
-			func() error { return servertest.SetOption(client, "serial", "on") },
 			func() error { return servertest.Commit(client, nil) },
 			func() error { return servertest.DeliverTx(client, []byte("abc"), code.CodeTypeBadNonce, nil) },
 			func() error { return servertest.Commit(client, nil) },
@@ -439,8 +432,6 @@ func muxOnCommands(cmd *cobra.Command, pArgs []string) error {
 		return cmdInfo(cmd, actualArgs)
 	case "query":
 		return cmdQuery(cmd, actualArgs)
-	case "set_option":
-		return cmdSetOption(cmd, actualArgs)
 	default:
 		return cmdUnimplemented(cmd, pArgs)
 	}
@@ -464,7 +455,6 @@ func cmdUnimplemented(cmd *cobra.Command, args []string) error {
 	fmt.Printf("%s: %s\n", deliverTxCmd.Use, deliverTxCmd.Short)
 	fmt.Printf("%s: %s\n", queryCmd.Use, queryCmd.Short)
 	fmt.Printf("%s: %s\n", commitCmd.Use, commitCmd.Short)
-	fmt.Printf("%s: %s\n", setOptionCmd.Use, setOptionCmd.Short)
 	fmt.Println("Use \"[command] --help\" for more information about a command.")
 
 	return nil
@@ -476,7 +466,7 @@ func cmdEcho(cmd *cobra.Command, args []string) error {
 	if len(args) > 0 {
 		msg = args[0]
 	}
-	res, err := client.EchoSync(msg)
+	res, err := client.EchoSync(ctx, msg)
 	if err != nil {
 		return err
 	}
@@ -492,7 +482,7 @@ func cmdInfo(cmd *cobra.Command, args []string) error {
 	if len(args) == 1 {
 		version = args[0]
 	}
-	res, err := client.InfoSync(types.RequestInfo{Version: version})
+	res, err := client.InfoSync(ctx, types.RequestInfo{Version: version})
 	if err != nil {
 		return err
 	}
@@ -504,25 +494,6 @@ func cmdInfo(cmd *cobra.Command, args []string) error {
 
 const codeBad uint32 = 10
 
-// Set an option on the application
-func cmdSetOption(cmd *cobra.Command, args []string) error {
-	if len(args) < 2 {
-		printResponse(cmd, args, response{
-			Code: codeBad,
-			Log:  "want at least arguments of the form: <key> <value>",
-		})
-		return nil
-	}
-
-	key, val := args[0], args[1]
-	_, err := client.SetOptionSync(types.RequestSetOption{Key: key, Value: val})
-	if err != nil {
-		return err
-	}
-	printResponse(cmd, args, response{Log: "OK (SetOption doesn't return anything.)"}) // NOTE: Nothing to show...
-	return nil
-}
-
 // Append a new tx to application
 func cmdDeliverTx(cmd *cobra.Command, args []string) error {
 	if len(args) == 0 {
@@ -536,7 +507,7 @@ func cmdDeliverTx(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	res, err := client.DeliverTxSync(types.RequestDeliverTx{Tx: txBytes})
+	res, err := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
 	if err != nil {
 		return err
 	}
@@ -562,7 +533,7 @@ func cmdCheckTx(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	res, err := client.CheckTxSync(types.RequestCheckTx{Tx: txBytes})
+	res, err := client.CheckTxSync(ctx, types.RequestCheckTx{Tx: txBytes})
 	if err != nil {
 		return err
 	}
@@ -577,7 +548,7 @@ func cmdCheckTx(cmd *cobra.Command, args []string) error {
 
 // Get application Merkle root hash
 func cmdCommit(cmd *cobra.Command, args []string) error {
-	res, err := client.CommitSync()
+	res, err := client.CommitSync(ctx)
 	if err != nil {
 		return err
 	}
@@ -602,7 +573,7 @@ func cmdQuery(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	resQuery, err := client.QuerySync(types.RequestQuery{
+	resQuery, err := client.QuerySync(ctx, types.RequestQuery{
 		Data:   queryBytes,
 		Path:   flagPath,
 		Height: int64(flagHeight),

abci/example/counter/counter.go

@@ -24,24 +24,6 @@ func (app *Application) Info(req types.RequestInfo) types.ResponseInfo {
 	return types.ResponseInfo{Data: fmt.Sprintf("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
 }
 
-func (app *Application) SetOption(req types.RequestSetOption) types.ResponseSetOption {
-	key, value := req.Key, req.Value
-	if key == "serial" && value == "on" {
-		app.serial = true
-	} else {
-		/*
-			TODO Panic and have the ABCI server pass an exception.
-			The client can call SetOptionSync() and get an `error`.
-			return types.ResponseSetOption{
-				Error: fmt.Sprintf("Unknown key (%s) or value (%s)", key, value),
-			}
-		*/
-		return types.ResponseSetOption{}
-	}
-
-	return types.ResponseSetOption{}
-}
-
 func (app *Application) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverTx {
 	if app.serial {
 		if len(req.Tx) > 8 {
@@ -69,6 +51,7 @@ func (app *Application) CheckTx(req types.RequestCheckTx) types.ResponseCheckTx
 				Code: code.CodeTypeEncodingError,
 				Log:  fmt.Sprintf("Max tx size is 8 bytes, got %d", len(req.Tx))}
 		}
+
 		tx8 := make([]byte, 8)
 		copy(tx8[len(tx8)-len(req.Tx):], req.Tx)
 		txValue := binary.BigEndian.Uint64(tx8)

abci/example/example_test.go

@@ -1,6 +1,7 @@
 package example
 
 import (
+	"context"
 	"fmt"
 	"math/rand"
 	"net"
@@ -13,8 +14,6 @@ import (
 
 	"google.golang.org/grpc"
 
-	"golang.org/x/net/context"
-
 	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 
@@ -45,7 +44,7 @@ func TestGRPC(t *testing.T) {
 }
 
 func testStream(t *testing.T, app types.Application) {
-	numDeliverTxs := 20000
+	const numDeliverTxs = 20000
 	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
 	defer os.Remove(socketFile)
 	socket := fmt.Sprintf("unix://%v", socketFile)
@@ -53,9 +52,8 @@ func testStream(t *testing.T, app types.Application) {
 	// Start the listener
 	server := abciserver.NewSocketServer(socket, app)
 	server.SetLogger(log.TestingLogger().With("module", "abci-server"))
-	if err := server.Start(); err != nil {
-		require.NoError(t, err, "Error starting socket server")
-	}
+	err := server.Start()
+	require.NoError(t, err)
 	t.Cleanup(func() {
 		if err := server.Stop(); err != nil {
 			t.Error(err)
@@ -65,9 +63,8 @@ func testStream(t *testing.T, app types.Application) {
 	// Connect to the socket
 	client := abcicli.NewSocketClient(socket, false)
 	client.SetLogger(log.TestingLogger().With("module", "abci-client"))
-	if err := client.Start(); err != nil {
-		t.Fatalf("Error starting socket client: %v", err.Error())
-	}
+	err = client.Start()
+	require.NoError(t, err)
 	t.Cleanup(func() {
 		if err := client.Stop(); err != nil {
 			t.Error(err)
@@ -101,22 +98,24 @@ func testStream(t *testing.T, app types.Application) {
 		}
 	})
 
+	ctx := context.Background()
+
 	// Write requests
 	for counter := 0; counter < numDeliverTxs; counter++ {
 		// Send request
-		reqRes := client.DeliverTxAsync(types.RequestDeliverTx{Tx: []byte("test")})
-		_ = reqRes
-		// check err ?
+		_, err = client.DeliverTxAsync(ctx, types.RequestDeliverTx{Tx: []byte("test")})
+		require.NoError(t, err)
 
 		// Sometimes send flush messages
-		if counter%123 == 0 {
-			client.FlushAsync()
-			// check err ?
+		if counter%128 == 0 {
+			err = client.FlushSync(context.Background())
+			require.NoError(t, err)
 		}
 	}
 
 	// Send final flush message
-	client.FlushAsync()
+	_, err = client.FlushAsync(ctx)
+	require.NoError(t, err)
 
 	<-done
 }
@@ -130,7 +129,7 @@ func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
 
 func testGRPCSync(t *testing.T, app types.ABCIApplicationServer) {
 	numDeliverTxs := 2000
-	socketFile := fmt.Sprintf("/tmp/test-%08x.sock", rand.Int31n(1<<30))
+	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
 	defer os.Remove(socketFile)
 	socket := fmt.Sprintf("unix://%v", socketFile)
 
@@ -148,7 +147,6 @@ func testGRPCSync(t *testing.T, app types.ABCIApplicationServer) {
 	})
 
 	// Connect to the socket
-	//nolint:staticcheck // SA1019 Existing use of deprecated but supported dial option.
 	conn, err := grpc.Dial(socket, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
 	if err != nil {
 		t.Fatalf("Error dialing GRPC server: %v", err.Error())

abci/example/kvstore/helpers.go

@@ -1,6 +1,8 @@
 package kvstore
 
 import (
+	mrand "math/rand"
+
 	"github.com/tendermint/tendermint/abci/types"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 )
@@ -9,7 +11,8 @@ import (
 // from the input value
 func RandVal(i int) types.ValidatorUpdate {
 	pubkey := tmrand.Bytes(32)
-	power := tmrand.Uint16() + 1
+	// Random value between [0, 2^16 - 1]
+	power := mrand.Uint32() & (1<<16 - 1) // nolint:gosec // G404: Use of weak random number generator
 	v := types.UpdateValidator(pubkey, int64(power), "")
 	return v
 }

abci/example/kvstore/kvstore.go

@@ -87,15 +87,16 @@ func (app *Application) Info(req types.RequestInfo) (resInfo types.ResponseInfo)
 
 // tx is either "key=value" or just arbitrary bytes
 func (app *Application) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverTx {
-	var key, value []byte
+	var key, value string
+
 	parts := bytes.Split(req.Tx, []byte("="))
 	if len(parts) == 2 {
-		key, value = parts[0], parts[1]
+		key, value = string(parts[0]), string(parts[1])
 	} else {
-		key, value = req.Tx, req.Tx
+		key, value = string(req.Tx), string(req.Tx)
 	}
 
-	err := app.state.db.Set(prefixKey(key), value)
+	err := app.state.db.Set(prefixKey([]byte(key)), []byte(value))
 	if err != nil {
 		panic(err)
 	}
@@ -105,10 +106,10 @@ func (app *Application) DeliverTx(req types.RequestDeliverTx) types.ResponseDeli
 		{
 			Type: "app",
 			Attributes: []types.EventAttribute{
-				{Key: []byte("creator"), Value: []byte("Cosmoshi Netowoko"), Index: true},
-				{Key: []byte("key"), Value: key, Index: true},
-				{Key: []byte("index_key"), Value: []byte("index is working"), Index: true},
-				{Key: []byte("noindex_key"), Value: []byte("index is working"), Index: false},
+				{Key: "creator", Value: "Cosmoshi Netowoko", Index: true},
+				{Key: "key", Value: key, Index: true},
+				{Key: "index_key", Value: "index is working", Index: true},
+				{Key: "noindex_key", Value: "index is working", Index: false},
 			},
 		},
 	}

abci/example/kvstore/kvstore_test.go

@@ -1,6 +1,7 @@
 package kvstore
 
 import (
+	"context"
 	"fmt"
 	"io/ioutil"
 	"sort"
@@ -23,6 +24,8 @@ const (
 	testValue = "def"
 )
 
+var ctx = context.Background()
+
 func testKVStore(t *testing.T, app types.Application, tx []byte, key, value string) {
 	req := types.RequestDeliverTx{Tx: tx}
 	ar := app.DeliverTx(req)
@@ -293,7 +296,7 @@ func TestClientServer(t *testing.T) {
 
 	// set up grpc app
 	kvstore = NewApplication()
-	gclient, gserver, err := makeGRPCClientServer(kvstore, "/tmp/kvstore-grpc")
+	gclient, gserver, err := makeGRPCClientServer(kvstore, "kvstore-grpc")
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
@@ -323,23 +326,23 @@ func runClientTests(t *testing.T, client abcicli.Client) {
 }
 
 func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string) {
-	ar, err := app.DeliverTxSync(types.RequestDeliverTx{Tx: tx})
+	ar, err := app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
 	require.NoError(t, err)
 	require.False(t, ar.IsErr(), ar)
 	// repeating tx doesn't raise error
-	ar, err = app.DeliverTxSync(types.RequestDeliverTx{Tx: tx})
+	ar, err = app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
 	require.NoError(t, err)
 	require.False(t, ar.IsErr(), ar)
 	// commit
-	_, err = app.CommitSync()
+	_, err = app.CommitSync(ctx)
 	require.NoError(t, err)
 
-	info, err := app.InfoSync(types.RequestInfo{})
+	info, err := app.InfoSync(ctx, types.RequestInfo{})
 	require.NoError(t, err)
 	require.NotZero(t, info.LastBlockHeight)
 
 	// make sure query is fine
-	resQuery, err := app.QuerySync(types.RequestQuery{
+	resQuery, err := app.QuerySync(ctx, types.RequestQuery{
 		Path: "/store",
 		Data: []byte(key),
 	})
@@ -350,7 +353,7 @@ func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string)
 	require.EqualValues(t, info.LastBlockHeight, resQuery.Height)
 
 	// make sure proof is fine
-	resQuery, err = app.QuerySync(types.RequestQuery{
+	resQuery, err = app.QuerySync(ctx, types.RequestQuery{
 		Path:  "/store",
 		Data:  []byte(key),
 		Prove: true,

abci/example/kvstore/persistent_kvstore.go

@@ -51,6 +51,10 @@ func NewPersistentKVStoreApplication(dbDir string) *PersistentKVStoreApplication
 	}
 }
 
+func (app *PersistentKVStoreApplication) Close() error {
+	return app.app.state.db.Close()
+}
+
 func (app *PersistentKVStoreApplication) SetLogger(l log.Logger) {
 	app.logger = l
 }
@@ -62,10 +66,6 @@ func (app *PersistentKVStoreApplication) Info(req types.RequestInfo) types.Respo
 	return res
 }
 
-func (app *PersistentKVStoreApplication) SetOption(req types.RequestSetOption) types.ResponseSetOption {
-	return app.app.SetOption(req)
-}
-
 // tx is either "val:pubkey!power" or "key=value" or just arbitrary bytes
 func (app *PersistentKVStoreApplication) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverTx {
 	// if it starts with "val:", update the validator set

abci/server/socket_server.go

@@ -200,9 +200,6 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_Info:
 		res := s.app.Info(*r.Info)
 		responses <- types.ToResponseInfo(res)
-	case *types.Request_SetOption:
-		res := s.app.SetOption(*r.SetOption)
-		responses <- types.ToResponseSetOption(res)
 	case *types.Request_DeliverTx:
 		res := s.app.DeliverTx(*r.DeliverTx)
 		responses <- types.ToResponseDeliverTx(res)

abci/tests/server/client.go

@@ -2,23 +2,28 @@ package testsuite
 
 import (
 	"bytes"
+	"context"
 	"errors"
 	"fmt"
+	mrand "math/rand"
 
 	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/types"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 )
 
+var ctx = context.Background()
+
 func InitChain(client abcicli.Client) error {
 	total := 10
 	vals := make([]types.ValidatorUpdate, total)
 	for i := 0; i < total; i++ {
 		pubkey := tmrand.Bytes(33)
-		power := tmrand.Int()
+		// nolint:gosec // G404: Use of weak random number generator
+		power := mrand.Int()
 		vals[i] = types.UpdateValidator(pubkey, int64(power), "")
 	}
-	_, err := client.InitChainSync(types.RequestInitChain{
+	_, err := client.InitChainSync(ctx, types.RequestInitChain{
 		Validators: vals,
 	})
 	if err != nil {
@@ -29,19 +34,8 @@ func InitChain(client abcicli.Client) error {
 	return nil
 }
 
-func SetOption(client abcicli.Client, key, value string) error {
-	_, err := client.SetOptionSync(types.RequestSetOption{Key: key, Value: value})
-	if err != nil {
-		fmt.Println("Failed test: SetOption")
-		fmt.Printf("error while setting %v=%v: \nerror: %v\n", key, value, err)
-		return err
-	}
-	fmt.Println("Passed test: SetOption")
-	return nil
-}
-
 func Commit(client abcicli.Client, hashExp []byte) error {
-	res, err := client.CommitSync()
+	res, err := client.CommitSync(ctx)
 	data := res.Data
 	if err != nil {
 		fmt.Println("Failed test: Commit")
@@ -58,7 +52,7 @@ func Commit(client abcicli.Client, hashExp []byte) error {
 }
 
 func DeliverTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
-	res, _ := client.DeliverTxSync(types.RequestDeliverTx{Tx: txBytes})
+	res, _ := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {
 		fmt.Println("Failed test: DeliverTx")
@@ -77,7 +71,7 @@ func DeliverTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []
 }
 
 func CheckTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
-	res, _ := client.CheckTxSync(types.RequestCheckTx{Tx: txBytes})
+	res, _ := client.CheckTxSync(ctx, types.RequestCheckTx{Tx: txBytes})
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {
 		fmt.Println("Failed test: CheckTx")

abci/tests/test_app/app.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"os"
 
@@ -10,6 +11,8 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 )
 
+var ctx = context.Background()
+
 func startClient(abciType string) abcicli.Client {
 	// Start client
 	client, err := abcicli.NewClient("tcp://127.0.0.1:26658", abciType, true)
@@ -25,15 +28,8 @@ func startClient(abciType string) abcicli.Client {
 	return client
 }
 
-func setOption(client abcicli.Client, key, value string) {
-	_, err := client.SetOptionSync(types.RequestSetOption{Key: key, Value: value})
-	if err != nil {
-		panicf("setting %v=%v: \nerr: %v", key, value, err)
-	}
-}
-
 func commit(client abcicli.Client, hashExp []byte) {
-	res, err := client.CommitSync()
+	res, err := client.CommitSync(ctx)
 	if err != nil {
 		panicf("client error: %v", err)
 	}
@@ -43,7 +39,7 @@ func commit(client abcicli.Client, hashExp []byte) {
 }
 
 func deliverTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) {
-	res, err := client.DeliverTxSync(types.RequestDeliverTx{Tx: txBytes})
+	res, err := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
 	if err != nil {
 		panicf("client error: %v", err)
 	}
@@ -55,24 +51,6 @@ func deliverTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []
 	}
 }
 
-/*func checkTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) {
-	res, err := client.CheckTxSync(txBytes)
-	if err != nil {
-		panicf("client error: %v", err)
-	}
-	if res.IsErr() {
-		panicf("checking tx %X: %v\nlog: %v", txBytes, res.Log)
-	}
-	if res.Code != codeExp {
-		panicf("CheckTx response code was unexpected. Got %v expected %v. Log: %v",
-			res.Code, codeExp, res.Log)
-	}
-	if !bytes.Equal(res.Data, dataExp) {
-		panicf("CheckTx response data was unexpected. Got %X expected %X",
-			res.Data, dataExp)
-	}
-}*/
-
 func panicf(format string, a ...interface{}) {
 	panic(fmt.Sprintf(format, a...))
 }

abci/tests/test_app/main.go

@@ -7,7 +7,6 @@ import (
 	"os/exec"
 	"time"
 
-	"github.com/tendermint/tendermint/abci/example/code"
 	"github.com/tendermint/tendermint/abci/types"
 )
 
@@ -41,7 +40,7 @@ func ensureABCIIsUp(typ string, n int) error {
 		if err == nil {
 			break
 		}
-		<-time.After(500 * time.Millisecond)
+		time.Sleep(500 * time.Millisecond)
 	}
 	return err
 }
@@ -79,17 +78,16 @@ func testCounter() {
 		}
 	}()
 
-	setOption(client, "serial", "on")
-	commit(client, nil)
-	deliverTx(client, []byte("abc"), code.CodeTypeBadNonce, nil)
+	// commit(client, nil)
+	// deliverTx(client, []byte("abc"), code.CodeTypeBadNonce, nil)
 	commit(client, nil)
 	deliverTx(client, []byte{0x00}, types.CodeTypeOK, nil)
 	commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 1})
-	deliverTx(client, []byte{0x00}, code.CodeTypeBadNonce, nil)
+	// deliverTx(client, []byte{0x00}, code.CodeTypeBadNonce, nil)
 	deliverTx(client, []byte{0x01}, types.CodeTypeOK, nil)
 	deliverTx(client, []byte{0x00, 0x02}, types.CodeTypeOK, nil)
 	deliverTx(client, []byte{0x00, 0x03}, types.CodeTypeOK, nil)
 	deliverTx(client, []byte{0x00, 0x00, 0x04}, types.CodeTypeOK, nil)
-	deliverTx(client, []byte{0x00, 0x00, 0x06}, code.CodeTypeBadNonce, nil)
+	// deliverTx(client, []byte{0x00, 0x00, 0x06}, code.CodeTypeBadNonce, nil)
 	commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5})
 }

abci/tests/test_cli/ex2.abci

@@ -1,4 +1,3 @@
-set_option serial on
 check_tx 0x00
 check_tx 0xff
 deliver_tx 0x00

abci/tests/test_cli/ex2.abci.out

@@ -1,7 +1,3 @@
-> set_option serial on
--> code: OK
--> log: OK (SetOption doesn't return anything.)
-
 > check_tx 0x00
 -> code: OK
 
@@ -12,18 +8,16 @@
 -> code: OK
 
 > check_tx 0x00
--> code: 2
--> log: Invalid nonce. Expected >= 1, got 0
+-> code: OK
 
 > deliver_tx 0x01
 -> code: OK
 
 > deliver_tx 0x04
--> code: 2
--> log: Invalid nonce. Expected 2, got 4
+-> code: OK
 
 > info 
 -> code: OK
--> data: {"hashes":0,"txs":2}
--> data.hex: 0x7B22686173686573223A302C22747873223A327D
+-> data: {"hashes":0,"txs":3}
+-> data.hex: 0x7B22686173686573223A302C22747873223A337D
 

abci/types/application.go

@@ -1,7 +1,7 @@
 package types
 
 import (
-	context "golang.org/x/net/context"
+	"context"
 )
 
 // Application is an interface that enables any finite, deterministic state machine
@@ -10,9 +10,8 @@ import (
 // except CheckTx/DeliverTx, which take `tx []byte`, and `Commit`, which takes nothing.
 type Application interface {
 	// Info/Query Connection
-	Info(RequestInfo) ResponseInfo                // Return application info
-	SetOption(RequestSetOption) ResponseSetOption // Set application option
-	Query(RequestQuery) ResponseQuery             // Query for state
+	Info(RequestInfo) ResponseInfo    // Return application info
+	Query(RequestQuery) ResponseQuery // Query for state
 
 	// Mempool Connection
 	CheckTx(RequestCheckTx) ResponseCheckTx // Validate a tx for the mempool
@@ -47,10 +46,6 @@ func (BaseApplication) Info(req RequestInfo) ResponseInfo {
 	return ResponseInfo{}
 }
 
-func (BaseApplication) SetOption(req RequestSetOption) ResponseSetOption {
-	return ResponseSetOption{}
-}
-
 func (BaseApplication) DeliverTx(req RequestDeliverTx) ResponseDeliverTx {
 	return ResponseDeliverTx{Code: CodeTypeOK}
 }
@@ -119,11 +114,6 @@ func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*Respon
 	return &res, nil
 }
 
-func (app *GRPCApplication) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) {
-	res := app.app.SetOption(*req)
-	return &res, nil
-}
-
 func (app *GRPCApplication) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) {
 	res := app.app.DeliverTx(*req)
 	return &res, nil

abci/types/messages.go

@@ -1,11 +1,10 @@
 package types
 
 import (
-	"bufio"
-	"encoding/binary"
 	"io"
 
 	"github.com/gogo/protobuf/proto"
+	"github.com/tendermint/tendermint/libs/protoio"
 )
 
 const (
@@ -14,57 +13,19 @@ const (
 
 // WriteMessage writes a varint length-delimited protobuf message.
 func WriteMessage(msg proto.Message, w io.Writer) error {
-	bz, err := proto.Marshal(msg)
+	protoWriter := protoio.NewDelimitedWriter(w)
+	_, err := protoWriter.WriteMsg(msg)
 	if err != nil {
 		return err
 	}
-	return encodeByteSlice(w, bz)
+
+	return nil
 }
 
 // ReadMessage reads a varint length-delimited protobuf message.
 func ReadMessage(r io.Reader, msg proto.Message) error {
-	return readProtoMsg(r, msg, maxMsgSize)
-}
-
-func readProtoMsg(r io.Reader, msg proto.Message, maxSize int) error {
-	// binary.ReadVarint takes an io.ByteReader, eg. a bufio.Reader
-	reader, ok := r.(*bufio.Reader)
-	if !ok {
-		reader = bufio.NewReader(r)
-	}
-	length64, err := binary.ReadVarint(reader)
-	if err != nil {
-		return err
-	}
-	length := int(length64)
-	if length < 0 || length > maxSize {
-		return io.ErrShortBuffer
-	}
-	buf := make([]byte, length)
-	if _, err := io.ReadFull(reader, buf); err != nil {
-		return err
-	}
-	return proto.Unmarshal(buf, msg)
-}
-
-//-----------------------------------------------------------------------
-// NOTE: we copied wire.EncodeByteSlice from go-wire rather than keep
-// go-wire as a dep
-
-func encodeByteSlice(w io.Writer, bz []byte) (err error) {
-	err = encodeVarint(w, int64(len(bz)))
-	if err != nil {
-		return
-	}
-	_, err = w.Write(bz)
-	return
-}
-
-func encodeVarint(w io.Writer, i int64) (err error) {
-	var buf [10]byte
-	n := binary.PutVarint(buf[:], i)
-	_, err = w.Write(buf[0:n])
-	return
+	_, err := protoio.NewDelimitedReader(r, maxMsgSize).ReadMsg(msg)
+	return err
 }
 
 //----------------------------------------
@@ -87,12 +48,6 @@ func ToRequestInfo(req RequestInfo) *Request {
 	}
 }
 
-func ToRequestSetOption(req RequestSetOption) *Request {
-	return &Request{
-		Value: &Request_SetOption{&req},
-	}
-}
-
 func ToRequestDeliverTx(req RequestDeliverTx) *Request {
 	return &Request{
 		Value: &Request_DeliverTx{&req},
@@ -184,13 +139,6 @@ func ToResponseInfo(res ResponseInfo) *Response {
 		Value: &Response_Info{&res},
 	}
 }
-
-func ToResponseSetOption(res ResponseSetOption) *Response {
-	return &Response{
-		Value: &Response_SetOption{&res},
-	}
-}
-
 func ToResponseDeliverTx(res ResponseDeliverTx) *Response {
 	return &Response{
 		Value: &Response_DeliverTx{&res},

abci/types/messages_test.go

@@ -25,7 +25,7 @@ func TestMarshalJSON(t *testing.T) {
 			{
 				Type: "testEvent",
 				Attributes: []EventAttribute{
-					{Key: []byte("pho"), Value: []byte("bo")},
+					{Key: "pho", Value: "bo"},
 				},
 			},
 		},
@@ -92,7 +92,7 @@ func TestWriteReadMessage2(t *testing.T) {
 				{
 					Type: "testEvent",
 					Attributes: []EventAttribute{
-						{Key: []byte("abc"), Value: []byte("def")},
+						{Key: "abc", Value: "def"},
 					},
 				},
 			},

abci/types/pubkey.go

@@ -6,6 +6,7 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
+	"github.com/tendermint/tendermint/crypto/sr25519"
 )
 
 func Ed25519ValidatorUpdate(pk []byte, power int64) ValidatorUpdate {
@@ -17,7 +18,6 @@ func Ed25519ValidatorUpdate(pk []byte, power int64) ValidatorUpdate {
 	}
 
 	return ValidatorUpdate{
-		// Address:
 		PubKey: pkp,
 		Power:  power,
 	}
@@ -34,7 +34,16 @@ func UpdateValidator(pk []byte, power int64, keyType string) ValidatorUpdate {
 			panic(err)
 		}
 		return ValidatorUpdate{
-			// Address:
+			PubKey: pkp,
+			Power:  power,
+		}
+	case sr25519.KeyType:
+		pke := sr25519.PubKey(pk)
+		pkp, err := cryptoenc.PubKeyToProto(pke)
+		if err != nil {
+			panic(err)
+		}
+		return ValidatorUpdate{
 			PubKey: pkp,
 			Power:  power,
 		}

abci/types/result.go

@@ -52,16 +52,6 @@ var (
 	jsonpbUnmarshaller = jsonpb.Unmarshaler{}
 )
 
-func (r *ResponseSetOption) MarshalJSON() ([]byte, error) {
-	s, err := jsonpbMarshaller.MarshalToString(r)
-	return []byte(s), err
-}
-
-func (r *ResponseSetOption) UnmarshalJSON(b []byte) error {
-	reader := bytes.NewBuffer(b)
-	return jsonpbUnmarshaller.Unmarshal(reader, r)
-}
-
 func (r *ResponseCheckTx) MarshalJSON() ([]byte, error) {
 	s, err := jsonpbMarshaller.MarshalToString(r)
 	return []byte(s), err
@@ -126,6 +116,5 @@ var _ jsonRoundTripper = (*ResponseCommit)(nil)
 var _ jsonRoundTripper = (*ResponseQuery)(nil)
 var _ jsonRoundTripper = (*ResponseDeliverTx)(nil)
 var _ jsonRoundTripper = (*ResponseCheckTx)(nil)
-var _ jsonRoundTripper = (*ResponseSetOption)(nil)
 
 var _ jsonRoundTripper = (*EventAttribute)(nil)

appveyor.yml

@@ -1,12 +0,0 @@
-version: 1.0.{build}
-configuration: Release
-platform:
-- x64
-- x86
-clone_folder: c:\go\path\src\github.com\tendermint\tendermint
-before_build:
-- cmd: set GOPATH=%GOROOT%\path
-- cmd: set PATH=%GOPATH%\bin;%PATH%
-build_script:
-- cmd: make test
-test: off

behaviour/peer_behaviour.go

@@ -1,49 +0,0 @@
-package behaviour
-
-import (
-	"github.com/tendermint/tendermint/p2p"
-)
-
-// PeerBehaviour is a struct describing a behaviour a peer performed.
-// `peerID` identifies the peer and reason characterizes the specific
-// behaviour performed by the peer.
-type PeerBehaviour struct {
-	peerID p2p.ID
-	reason interface{}
-}
-
-type badMessage struct {
-	explanation string
-}
-
-// BadMessage returns a badMessage PeerBehaviour.
-func BadMessage(peerID p2p.ID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: badMessage{explanation}}
-}
-
-type messageOutOfOrder struct {
-	explanation string
-}
-
-// MessageOutOfOrder returns a messagOutOfOrder PeerBehaviour.
-func MessageOutOfOrder(peerID p2p.ID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: messageOutOfOrder{explanation}}
-}
-
-type consensusVote struct {
-	explanation string
-}
-
-// ConsensusVote returns a consensusVote PeerBehaviour.
-func ConsensusVote(peerID p2p.ID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: consensusVote{explanation}}
-}
-
-type blockPart struct {
-	explanation string
-}
-
-// BlockPart returns blockPart PeerBehaviour.
-func BlockPart(peerID p2p.ID, explanation string) PeerBehaviour {
-	return PeerBehaviour{peerID: peerID, reason: blockPart{explanation}}
-}

behaviour/reporter_test.go

@@ -1,205 +0,0 @@
-package behaviour_test
-
-import (
-	"sync"
-	"testing"
-
-	bh "github.com/tendermint/tendermint/behaviour"
-	"github.com/tendermint/tendermint/p2p"
-)
-
-// TestMockReporter tests the MockReporter's ability to store reported
-// peer behaviour in memory indexed by the peerID.
-func TestMockReporter(t *testing.T) {
-	var peerID p2p.ID = "MockPeer"
-	pr := bh.NewMockReporter()
-
-	behaviours := pr.GetBehaviours(peerID)
-	if len(behaviours) != 0 {
-		t.Error("Expected to have no behaviours reported")
-	}
-
-	badMessage := bh.BadMessage(peerID, "bad message")
-	if err := pr.Report(badMessage); err != nil {
-		t.Error(err)
-	}
-	behaviours = pr.GetBehaviours(peerID)
-	if len(behaviours) != 1 {
-		t.Error("Expected the peer have one reported behaviour")
-	}
-
-	if behaviours[0] != badMessage {
-		t.Error("Expected Bad Message to have been reported")
-	}
-}
-
-type scriptItem struct {
-	peerID    p2p.ID
-	behaviour bh.PeerBehaviour
-}
-
-// equalBehaviours returns true if a and b contain the same PeerBehaviours with
-// the same freequencies and otherwise false.
-func equalBehaviours(a []bh.PeerBehaviour, b []bh.PeerBehaviour) bool {
-	aHistogram := map[bh.PeerBehaviour]int{}
-	bHistogram := map[bh.PeerBehaviour]int{}
-
-	for _, behaviour := range a {
-		aHistogram[behaviour]++
-	}
-
-	for _, behaviour := range b {
-		bHistogram[behaviour]++
-	}
-
-	if len(aHistogram) != len(bHistogram) {
-		return false
-	}
-
-	for _, behaviour := range a {
-		if aHistogram[behaviour] != bHistogram[behaviour] {
-			return false
-		}
-	}
-
-	for _, behaviour := range b {
-		if bHistogram[behaviour] != aHistogram[behaviour] {
-			return false
-		}
-	}
-
-	return true
-}
-
-// TestEqualPeerBehaviours tests that equalBehaviours can tell that two slices
-// of peer behaviours can be compared for the behaviours they contain and the
-// freequencies that those behaviours occur.
-func TestEqualPeerBehaviours(t *testing.T) {
-	var (
-		peerID        p2p.ID = "MockPeer"
-		consensusVote        = bh.ConsensusVote(peerID, "voted")
-		blockPart            = bh.BlockPart(peerID, "blocked")
-		equals               = []struct {
-			left  []bh.PeerBehaviour
-			right []bh.PeerBehaviour
-		}{
-			// Empty sets
-			{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{}},
-			// Single behaviours
-			{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{consensusVote}},
-			// Equal Frequencies
-			{[]bh.PeerBehaviour{consensusVote, consensusVote},
-				[]bh.PeerBehaviour{consensusVote, consensusVote}},
-			// Equal frequencies different orders
-			{[]bh.PeerBehaviour{consensusVote, blockPart},
-				[]bh.PeerBehaviour{blockPart, consensusVote}},
-		}
-		unequals = []struct {
-			left  []bh.PeerBehaviour
-			right []bh.PeerBehaviour
-		}{
-			// Comparing empty sets to non empty sets
-			{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{consensusVote}},
-			// Different behaviours
-			{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{blockPart}},
-			// Same behaviour with different frequencies
-			{[]bh.PeerBehaviour{consensusVote},
-				[]bh.PeerBehaviour{consensusVote, consensusVote}},
-		}
-	)
-
-	for _, test := range equals {
-		if !equalBehaviours(test.left, test.right) {
-			t.Errorf("expected %#v and %#v to be equal", test.left, test.right)
-		}
-	}
-
-	for _, test := range unequals {
-		if equalBehaviours(test.left, test.right) {
-			t.Errorf("expected %#v and %#v to be unequal", test.left, test.right)
-		}
-	}
-}
-
-// TestPeerBehaviourConcurrency constructs a scenario in which
-// multiple goroutines are using the same MockReporter instance.
-// This test reproduces the conditions in which MockReporter will
-// be used within a Reactor `Receive` method tests to ensure thread safety.
-func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
-	var (
-		behaviourScript = []struct {
-			peerID     p2p.ID
-			behaviours []bh.PeerBehaviour
-		}{
-			{"1", []bh.PeerBehaviour{bh.ConsensusVote("1", "")}},
-			{"2", []bh.PeerBehaviour{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
-			{
-				"3",
-				[]bh.PeerBehaviour{bh.BlockPart("3", ""),
-					bh.ConsensusVote("3", ""),
-					bh.BlockPart("3", ""),
-					bh.ConsensusVote("3", "")}},
-			{
-				"4",
-				[]bh.PeerBehaviour{bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", "")}},
-			{
-				"5",
-				[]bh.PeerBehaviour{bh.BlockPart("5", ""),
-					bh.ConsensusVote("5", ""),
-					bh.BlockPart("5", ""),
-					bh.ConsensusVote("5", "")}},
-		}
-	)
-
-	var receiveWg sync.WaitGroup
-	pr := bh.NewMockReporter()
-	scriptItems := make(chan scriptItem)
-	done := make(chan int)
-	numConsumers := 3
-	for i := 0; i < numConsumers; i++ {
-		receiveWg.Add(1)
-		go func() {
-			defer receiveWg.Done()
-			for {
-				select {
-				case pb := <-scriptItems:
-					if err := pr.Report(pb.behaviour); err != nil {
-						t.Error(err)
-					}
-				case <-done:
-					return
-				}
-			}
-		}()
-	}
-
-	var sendingWg sync.WaitGroup
-	sendingWg.Add(1)
-	go func() {
-		defer sendingWg.Done()
-		for _, item := range behaviourScript {
-			for _, reason := range item.behaviours {
-				scriptItems <- scriptItem{item.peerID, reason}
-			}
-		}
-	}()
-
-	sendingWg.Wait()
-
-	for i := 0; i < numConsumers; i++ {
-		done <- 1
-	}
-
-	receiveWg.Wait()
-
-	for _, items := range behaviourScript {
-		reported := pr.GetBehaviours(items.peerID)
-		if !equalBehaviours(reported, items.behaviours) {
-			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
-				items.peerID, items.behaviours, reported)
-		}
-	}
-}

blockchain/doc.go

@@ -0,0 +1,17 @@
+/*
+Package blockchain provides two implementations of the fast-sync protocol.
+
+- v0 was the very first implementation. it's battle tested, but does not have a
+lot of test coverage.
+- v2 is the newest implementation, with a focus on testability and readability.
+
+Check out ADR-40 for the formal model and requirements.
+
+# Termination criteria
+
+1. the maximum peer height is reached
+2. termination timeout is triggered, which is set if the peer set is empty or
+there are no pending requests.
+
+*/
+package blockchain

blockchain/msgs.go

@@ -0,0 +1,12 @@
+package blockchain
+
+import (
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	"github.com/tendermint/tendermint/types"
+)
+
+const (
+	MaxMsgSize = types.MaxBlockSizeBytes +
+		bcproto.BlockResponseMessagePrefixSize +
+		bcproto.BlockResponseMessageFieldKeySize
+)

blockchain/v0/pool.go

@@ -30,6 +30,7 @@ eg, L = latency = 0.1s
 const (
 	requestIntervalMS         = 2
 	maxTotalRequesters        = 600
+	maxPeerErrBuffer          = 1000
 	maxPendingRequests        = maxTotalRequesters
 	maxPendingRequestsPerPeer = 20
 
@@ -58,17 +59,24 @@ var peerTimeout = 15 * time.Second // not const so we can override with tests
 	are not at peer limits, we can probably switch to consensus reactor
 */
 
+// BlockRequest stores a block request identified by the block Height and the
+// PeerID responsible for delivering the block.
+type BlockRequest struct {
+	Height int64
+	PeerID p2p.NodeID
+}
+
 // BlockPool keeps track of the fast sync peers, block requests and block responses.
 type BlockPool struct {
 	service.BaseService
-	startTime time.Time
+	lastAdvance time.Time
 
-	mtx tmsync.Mutex
+	mtx tmsync.RWMutex
 	// block requests
 	requesters map[int64]*bpRequester
 	height     int64 // the lowest key in requesters.
 	// peers
-	peers         map[p2p.ID]*bpPeer
+	peers         map[p2p.NodeID]*bpPeer
 	maxPeerHeight int64 // the biggest reported height
 
 	// atomic
@@ -82,7 +90,7 @@ type BlockPool struct {
 // requests and errors will be sent to requestsCh and errorsCh accordingly.
 func NewBlockPool(start int64, requestsCh chan<- BlockRequest, errorsCh chan<- peerError) *BlockPool {
 	bp := &BlockPool{
-		peers: make(map[p2p.ID]*bpPeer),
+		peers: make(map[p2p.NodeID]*bpPeer),
 
 		requesters: make(map[int64]*bpRequester),
 		height:     start,
@@ -98,8 +106,8 @@ func NewBlockPool(start int64, requestsCh chan<- BlockRequest, errorsCh chan<- p
 // OnStart implements service.Service by spawning requesters routine and recording
 // pool's start time.
 func (pool *BlockPool) OnStart() error {
+	pool.lastAdvance = time.Now()
 	go pool.makeRequestersRoutine()
-	pool.startTime = time.Now()
 	return nil
 }
 
@@ -134,6 +142,7 @@ func (pool *BlockPool) removeTimedoutPeers() {
 	defer pool.mtx.Unlock()
 
 	for _, peer := range pool.peers {
+		// check if peer timed out
 		if !peer.didTimeout && peer.numPending > 0 {
 			curRate := peer.recvMonitor.Status().CurRate
 			// curRate can be 0 on start
@@ -147,6 +156,7 @@ func (pool *BlockPool) removeTimedoutPeers() {
 				peer.didTimeout = true
 			}
 		}
+
 		if peer.didTimeout {
 			pool.removePeer(peer.id)
 		}
@@ -156,33 +166,25 @@ func (pool *BlockPool) removeTimedoutPeers() {
 // GetStatus returns pool's height, numPending requests and the number of
 // requesters.
 func (pool *BlockPool) GetStatus() (height int64, numPending int32, lenRequesters int) {
-	pool.mtx.Lock()
-	defer pool.mtx.Unlock()
+	pool.mtx.RLock()
+	defer pool.mtx.RUnlock()
 
 	return pool.height, atomic.LoadInt32(&pool.numPending), len(pool.requesters)
 }
 
 // IsCaughtUp returns true if this node is caught up, false - otherwise.
-// TODO: relax conditions, prevent abuse.
 func (pool *BlockPool) IsCaughtUp() bool {
-	pool.mtx.Lock()
-	defer pool.mtx.Unlock()
+	pool.mtx.RLock()
+	defer pool.mtx.RUnlock()
 
 	// Need at least 1 peer to be considered caught up.
 	if len(pool.peers) == 0 {
-		pool.Logger.Debug("Blockpool has no peers")
 		return false
 	}
 
-	// Some conditions to determine if we're caught up.
-	// Ensures we've either received a block or waited some amount of time,
-	// and that we're synced to the highest known height.
-	// Note we use maxPeerHeight - 1 because to sync block H requires block H+1
+	// NOTE: we use maxPeerHeight - 1 because to sync block H requires block H+1
 	// to verify the LastCommit.
-	receivedBlockOrTimedOut := pool.height > 0 || time.Since(pool.startTime) > 5*time.Second
-	ourChainIsLongestAmongPeers := pool.maxPeerHeight == 0 || pool.height >= (pool.maxPeerHeight-1)
-	isCaughtUp := receivedBlockOrTimedOut && ourChainIsLongestAmongPeers
-	return isCaughtUp
+	return pool.height >= (pool.maxPeerHeight - 1)
 }
 
 // PeekTwoBlocks returns blocks at pool.height and pool.height+1.
@@ -190,8 +192,8 @@ func (pool *BlockPool) IsCaughtUp() bool {
 // So we peek two blocks at a time.
 // The caller will verify the commit.
 func (pool *BlockPool) PeekTwoBlocks() (first *types.Block, second *types.Block) {
-	pool.mtx.Lock()
-	defer pool.mtx.Unlock()
+	pool.mtx.RLock()
+	defer pool.mtx.RUnlock()
 
 	if r := pool.requesters[pool.height]; r != nil {
 		first = r.getBlock()
@@ -209,16 +211,12 @@ func (pool *BlockPool) PopRequest() {
 	defer pool.mtx.Unlock()
 
 	if r := pool.requesters[pool.height]; r != nil {
-		/*  The block can disappear at any time, due to removePeer().
-		if r := pool.requesters[pool.height]; r == nil || r.block == nil {
-			PanicSanity("PopRequest() requires a valid block")
-		}
-		*/
 		if err := r.Stop(); err != nil {
 			pool.Logger.Error("Error stopping requester", "err", err)
 		}
 		delete(pool.requesters, pool.height)
 		pool.height++
+		pool.lastAdvance = time.Now()
 	} else {
 		panic(fmt.Sprintf("Expected requester to pop, got nothing at height %v", pool.height))
 	}
@@ -227,13 +225,13 @@ func (pool *BlockPool) PopRequest() {
 // RedoRequest invalidates the block at pool.height,
 // Remove the peer and redo request from others.
 // Returns the ID of the removed peer.
-func (pool *BlockPool) RedoRequest(height int64) p2p.ID {
+func (pool *BlockPool) RedoRequest(height int64) p2p.NodeID {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
 	request := pool.requesters[height]
 	peerID := request.getPeerID()
-	if peerID != p2p.ID("") {
+	if peerID != p2p.NodeID("") {
 		// RemovePeer will redo all requesters associated with this peer.
 		pool.removePeer(peerID)
 	}
@@ -242,20 +240,14 @@ func (pool *BlockPool) RedoRequest(height int64) p2p.ID {
 
 // AddBlock validates that the block comes from the peer it was expected from and calls the requester to store it.
 // TODO: ensure that blocks come in order for each peer.
-func (pool *BlockPool) AddBlock(peerID p2p.ID, block *types.Block, blockSize int) {
+func (pool *BlockPool) AddBlock(peerID p2p.NodeID, block *types.Block, blockSize int) {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
 	requester := pool.requesters[block.Height]
 	if requester == nil {
-		pool.Logger.Info(
-			"peer sent us a block we didn't expect",
-			"peer",
-			peerID,
-			"curHeight",
-			pool.height,
-			"blockHeight",
-			block.Height)
+		pool.Logger.Error("peer sent us a block we didn't expect",
+			"peer", peerID, "curHeight", pool.height, "blockHeight", block.Height)
 		diff := pool.height - block.Height
 		if diff < 0 {
 			diff *= -1
@@ -273,20 +265,29 @@ func (pool *BlockPool) AddBlock(peerID p2p.ID, block *types.Block, blockSize int
 			peer.decrPending(blockSize)
 		}
 	} else {
-		pool.Logger.Info("invalid peer", "peer", peerID, "blockHeight", block.Height)
-		pool.sendError(errors.New("invalid peer"), peerID)
+		err := errors.New("requester is different or block already exists")
+		pool.Logger.Error(err.Error(), "peer", peerID, "requester", requester.getPeerID(), "blockHeight", block.Height)
+		pool.sendError(err, peerID)
 	}
 }
 
 // MaxPeerHeight returns the highest reported height.
 func (pool *BlockPool) MaxPeerHeight() int64 {
-	pool.mtx.Lock()
-	defer pool.mtx.Unlock()
+	pool.mtx.RLock()
+	defer pool.mtx.RUnlock()
 	return pool.maxPeerHeight
 }
 
+// LastAdvance returns the time when the last block was processed (or start
+// time if no blocks were processed).
+func (pool *BlockPool) LastAdvance() time.Time {
+	pool.mtx.RLock()
+	defer pool.mtx.RUnlock()
+	return pool.lastAdvance
+}
+
 // SetPeerRange sets the peer's alleged blockchain base and height.
-func (pool *BlockPool) SetPeerRange(peerID p2p.ID, base int64, height int64) {
+func (pool *BlockPool) SetPeerRange(peerID p2p.NodeID, base int64, height int64) {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
@@ -307,14 +308,14 @@ func (pool *BlockPool) SetPeerRange(peerID p2p.ID, base int64, height int64) {
 
 // RemovePeer removes the peer with peerID from the pool. If there's no peer
 // with peerID, function is a no-op.
-func (pool *BlockPool) RemovePeer(peerID p2p.ID) {
+func (pool *BlockPool) RemovePeer(peerID p2p.NodeID) {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
 	pool.removePeer(peerID)
 }
 
-func (pool *BlockPool) removePeer(peerID p2p.ID) {
+func (pool *BlockPool) removePeer(peerID p2p.NodeID) {
 	for _, requester := range pool.requesters {
 		if requester.getPeerID() == peerID {
 			requester.redo(peerID)
@@ -395,14 +396,14 @@ func (pool *BlockPool) requestersLen() int64 {
 	return int64(len(pool.requesters))
 }
 
-func (pool *BlockPool) sendRequest(height int64, peerID p2p.ID) {
+func (pool *BlockPool) sendRequest(height int64, peerID p2p.NodeID) {
 	if !pool.IsRunning() {
 		return
 	}
 	pool.requestsCh <- BlockRequest{height, peerID}
 }
 
-func (pool *BlockPool) sendError(err error, peerID p2p.ID) {
+func (pool *BlockPool) sendError(err error, peerID p2p.NodeID) {
 	if !pool.IsRunning() {
 		return
 	}
@@ -436,7 +437,7 @@ type bpPeer struct {
 	height      int64
 	base        int64
 	pool        *BlockPool
-	id          p2p.ID
+	id          p2p.NodeID
 	recvMonitor *flow.Monitor
 
 	timeout *time.Timer
@@ -444,7 +445,7 @@ type bpPeer struct {
 	logger log.Logger
 }
 
-func newBPPeer(pool *BlockPool, peerID p2p.ID, base int64, height int64) *bpPeer {
+func newBPPeer(pool *BlockPool, peerID p2p.NodeID, base int64, height int64) *bpPeer {
 	peer := &bpPeer{
 		pool:       pool,
 		id:         peerID,
@@ -509,10 +510,10 @@ type bpRequester struct {
 	pool       *BlockPool
 	height     int64
 	gotBlockCh chan struct{}
-	redoCh     chan p2p.ID // redo may send multitime, add peerId to identify repeat
+	redoCh     chan p2p.NodeID // redo may send multitime, add peerId to identify repeat
 
 	mtx    tmsync.Mutex
-	peerID p2p.ID
+	peerID p2p.NodeID
 	block  *types.Block
 }
 
@@ -521,7 +522,7 @@ func newBPRequester(pool *BlockPool, height int64) *bpRequester {
 		pool:       pool,
 		height:     height,
 		gotBlockCh: make(chan struct{}, 1),
-		redoCh:     make(chan p2p.ID, 1),
+		redoCh:     make(chan p2p.NodeID, 1),
 
 		peerID: "",
 		block:  nil,
@@ -536,7 +537,7 @@ func (bpr *bpRequester) OnStart() error {
 }
 
 // Returns true if the peer matches and block doesn't already exist.
-func (bpr *bpRequester) setBlock(block *types.Block, peerID p2p.ID) bool {
+func (bpr *bpRequester) setBlock(block *types.Block, peerID p2p.NodeID) bool {
 	bpr.mtx.Lock()
 	if bpr.block != nil || bpr.peerID != peerID {
 		bpr.mtx.Unlock()
@@ -558,7 +559,7 @@ func (bpr *bpRequester) getBlock() *types.Block {
 	return bpr.block
 }
 
-func (bpr *bpRequester) getPeerID() p2p.ID {
+func (bpr *bpRequester) getPeerID() p2p.NodeID {
 	bpr.mtx.Lock()
 	defer bpr.mtx.Unlock()
 	return bpr.peerID
@@ -580,7 +581,7 @@ func (bpr *bpRequester) reset() {
 // Tells bpRequester to pick another peer and try again.
 // NOTE: Nonblocking, and does nothing if another redo
 // was already requested.
-func (bpr *bpRequester) redo(peerID p2p.ID) {
+func (bpr *bpRequester) redo(peerID p2p.NodeID) {
 	select {
 	case bpr.redoCh <- peerID:
 	default:
@@ -601,7 +602,6 @@ OUTER_LOOP:
 			}
 			peer = bpr.pool.pickIncrAvailablePeer(bpr.height)
 			if peer == nil {
-				// log.Info("No peers available", "height", height)
 				time.Sleep(requestIntervalMS * time.Millisecond)
 				continue PICK_PEER_LOOP
 			}
@@ -638,10 +638,3 @@ OUTER_LOOP:
 		}
 	}
 }
-
-// BlockRequest stores a block request identified by the block Height and the PeerID responsible for
-// delivering the block
-type BlockRequest struct {
-	Height int64
-	PeerID p2p.ID
-}

blockchain/v0/pool_test.go

@@ -2,6 +2,7 @@ package v0
 
 import (
 	"fmt"
+	mrand "math/rand"
 	"testing"
 	"time"
 
@@ -19,7 +20,7 @@ func init() {
 }
 
 type testPeer struct {
-	id        p2p.ID
+	id        p2p.NodeID
 	base      int64
 	height    int64
 	inputChan chan inputData // make sure each peer's data is sequential
@@ -49,7 +50,7 @@ func (p testPeer) simulateInput(input inputData) {
 	// input.t.Logf("Added block from peer %v (height: %v)", input.request.PeerID, input.request.Height)
 }
 
-type testPeers map[p2p.ID]testPeer
+type testPeers map[p2p.NodeID]testPeer
 
 func (ps testPeers) start() {
 	for _, v := range ps {
@@ -66,8 +67,8 @@ func (ps testPeers) stop() {
 func makePeers(numPeers int, minHeight, maxHeight int64) testPeers {
 	peers := make(testPeers, numPeers)
 	for i := 0; i < numPeers; i++ {
-		peerID := p2p.ID(tmrand.Str(12))
-		height := minHeight + tmrand.Int63n(maxHeight-minHeight)
+		peerID := p2p.NodeID(tmrand.Str(12))
+		height := minHeight + mrand.Int63n(maxHeight-minHeight)
 		base := minHeight + int64(i)
 		if base > height {
 			base = height
@@ -182,7 +183,7 @@ func TestBlockPoolTimeout(t *testing.T) {
 
 	// Pull from channels
 	counter := 0
-	timedOut := map[p2p.ID]struct{}{}
+	timedOut := map[p2p.NodeID]struct{}{}
 	for {
 		select {
 		case err := <-errorsCh:
@@ -203,7 +204,7 @@ func TestBlockPoolTimeout(t *testing.T) {
 func TestBlockPoolRemovePeer(t *testing.T) {
 	peers := make(testPeers, 10)
 	for i := 0; i < 10; i++ {
-		peerID := p2p.ID(fmt.Sprintf("%d", i+1))
+		peerID := p2p.NodeID(fmt.Sprintf("%d", i+1))
 		height := int64(i + 1)
 		peers[peerID] = testPeer{peerID, 0, height, make(chan inputData)}
 	}
@@ -227,10 +228,10 @@ func TestBlockPoolRemovePeer(t *testing.T) {
 	assert.EqualValues(t, 10, pool.MaxPeerHeight())
 
 	// remove not-existing peer
-	assert.NotPanics(t, func() { pool.RemovePeer(p2p.ID("Superman")) })
+	assert.NotPanics(t, func() { pool.RemovePeer(p2p.NodeID("Superman")) })
 
 	// remove peer with biggest height
-	pool.RemovePeer(p2p.ID("10"))
+	pool.RemovePeer(p2p.NodeID("10"))
 	assert.EqualValues(t, 9, pool.MaxPeerHeight())
 
 	// remove all peers

blockchain/v0/reactor.go

@@ -0,0 +1,578 @@
+package v0
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	bc "github.com/tendermint/tendermint/blockchain"
+	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tendermint/tendermint/libs/service"
+	"github.com/tendermint/tendermint/p2p"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	sm "github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/store"
+	"github.com/tendermint/tendermint/types"
+)
+
+var (
+	_ service.Service = (*Reactor)(nil)
+
+	// ChannelShims contains a map of ChannelDescriptorShim objects, where each
+	// object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding
+	// p2p proto.Message the new p2p Channel is responsible for handling.
+	//
+	//
+	// TODO: Remove once p2p refactor is complete.
+	// ref: https://github.com/tendermint/tendermint/issues/5670
+	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
+		BlockchainChannel: {
+			MsgType: new(bcproto.Message),
+			Descriptor: &p2p.ChannelDescriptor{
+				ID:                  byte(BlockchainChannel),
+				Priority:            5,
+				SendQueueCapacity:   1000,
+				RecvBufferCapacity:  50 * 4096,
+				RecvMessageCapacity: bc.MaxMsgSize,
+
+				MaxSendBytes: 100,
+			},
+		},
+	}
+)
+
+const (
+	// BlockchainChannel is a channel for blocks and status updates
+	BlockchainChannel = p2p.ChannelID(0x40)
+
+	trySyncIntervalMS = 10
+
+	// ask for best height every 10s
+	statusUpdateIntervalSeconds = 10
+
+	// check if we should switch to consensus reactor
+	switchToConsensusIntervalSeconds = 1
+
+	// switch to consensus after this duration of inactivity
+	syncTimeout = 60 * time.Second
+)
+
+type consensusReactor interface {
+	// For when we switch from blockchain reactor and fast sync to the consensus
+	// machine.
+	SwitchToConsensus(state sm.State, skipWAL bool)
+}
+
+type peerError struct {
+	err    error
+	peerID p2p.NodeID
+}
+
+func (e peerError) Error() string {
+	return fmt.Sprintf("error with peer %v: %s", e.peerID, e.err.Error())
+}
+
+// BlockchainReactor handles long-term catchup syncing.
+type Reactor struct {
+	service.BaseService
+
+	// immutable
+	initialState sm.State
+
+	blockExec   *sm.BlockExecutor
+	store       *store.BlockStore
+	pool        *BlockPool
+	consReactor consensusReactor
+	fastSync    bool
+
+	blockchainCh *p2p.Channel
+	peerUpdates  *p2p.PeerUpdates
+	closeCh      chan struct{}
+
+	requestsCh <-chan BlockRequest
+	errorsCh   <-chan peerError
+
+	// poolWG is used to synchronize the graceful shutdown of the poolRoutine and
+	// requestRoutine spawned goroutines when stopping the reactor and before
+	// stopping the p2p Channel(s).
+	poolWG sync.WaitGroup
+}
+
+// NewReactor returns new reactor instance.
+func NewReactor(
+	logger log.Logger,
+	state sm.State,
+	blockExec *sm.BlockExecutor,
+	store *store.BlockStore,
+	consReactor consensusReactor,
+	blockchainCh *p2p.Channel,
+	peerUpdates *p2p.PeerUpdates,
+	fastSync bool,
+) (*Reactor, error) {
+	if state.LastBlockHeight != store.Height() {
+		return nil, fmt.Errorf("state (%v) and store (%v) height mismatch", state.LastBlockHeight, store.Height())
+	}
+
+	startHeight := store.Height() + 1
+	if startHeight == 1 {
+		startHeight = state.InitialHeight
+	}
+
+	requestsCh := make(chan BlockRequest, maxTotalRequesters)
+	errorsCh := make(chan peerError, maxPeerErrBuffer) // NOTE: The capacity should be larger than the peer count.
+
+	r := &Reactor{
+		initialState: state,
+		blockExec:    blockExec,
+		store:        store,
+		pool:         NewBlockPool(startHeight, requestsCh, errorsCh),
+		consReactor:  consReactor,
+		fastSync:     fastSync,
+		requestsCh:   requestsCh,
+		errorsCh:     errorsCh,
+		blockchainCh: blockchainCh,
+		peerUpdates:  peerUpdates,
+		closeCh:      make(chan struct{}),
+	}
+
+	r.BaseService = *service.NewBaseService(logger, "Blockchain", r)
+	return r, nil
+}
+
+// OnStart starts separate go routines for each p2p Channel and listens for
+// envelopes on each. In addition, it also listens for peer updates and handles
+// messages on that p2p channel accordingly. The caller must be sure to execute
+// OnStop to ensure the outbound p2p Channels are closed.
+//
+// If fastSync is enabled, we also start the pool and the pool processing
+// goroutine. If the pool fails to start, an error is returned.
+func (r *Reactor) OnStart() error {
+	if r.fastSync {
+		if err := r.pool.Start(); err != nil {
+			return err
+		}
+
+		r.poolWG.Add(1)
+		go r.poolRoutine(false)
+	}
+
+	go r.processBlockchainCh()
+	go r.processPeerUpdates()
+
+	return nil
+}
+
+// OnStop stops the reactor by signaling to all spawned goroutines to exit and
+// blocking until they all exit.
+func (r *Reactor) OnStop() {
+	if r.fastSync {
+		if err := r.pool.Stop(); err != nil {
+			r.Logger.Error("failed to stop pool", "err", err)
+		}
+	}
+
+	// wait for the poolRoutine and requestRoutine goroutines to gracefully exit
+	r.poolWG.Wait()
+
+	// Close closeCh to signal to all spawned goroutines to gracefully exit. All
+	// p2p Channels should execute Close().
+	close(r.closeCh)
+
+	// Wait for all p2p Channels to be closed before returning. This ensures we
+	// can easily reason about synchronization of all p2p Channels and ensure no
+	// panics will occur.
+	<-r.blockchainCh.Done()
+	<-r.peerUpdates.Done()
+}
+
+// respondToPeer loads a block and sends it to the requesting peer, if we have it.
+// Otherwise, we'll respond saying we do not have it.
+func (r *Reactor) respondToPeer(msg *bcproto.BlockRequest, peerID p2p.NodeID) {
+	block := r.store.LoadBlock(msg.Height)
+	if block != nil {
+		blockProto, err := block.ToProto()
+		if err != nil {
+			r.Logger.Error("failed to convert msg to protobuf", "err", err)
+			return
+		}
+
+		r.blockchainCh.Out <- p2p.Envelope{
+			To:      peerID,
+			Message: &bcproto.BlockResponse{Block: blockProto},
+		}
+
+		return
+	}
+
+	r.Logger.Info("peer requesting a block we do not have", "peer", peerID, "height", msg.Height)
+	r.blockchainCh.Out <- p2p.Envelope{
+		To:      peerID,
+		Message: &bcproto.NoBlockResponse{Height: msg.Height},
+	}
+}
+
+// handleBlockchainMessage handles envelopes sent from peers on the
+// BlockchainChannel. It returns an error only if the Envelope.Message is unknown
+// for this channel. This should never be called outside of handleMessage.
+func (r *Reactor) handleBlockchainMessage(envelope p2p.Envelope) error {
+	logger := r.Logger.With("peer", envelope.From)
+
+	switch msg := envelope.Message.(type) {
+	case *bcproto.BlockRequest:
+		r.respondToPeer(msg, envelope.From)
+
+	case *bcproto.BlockResponse:
+		block, err := types.BlockFromProto(msg.Block)
+		if err != nil {
+			logger.Error("failed to convert block from proto", "err", err)
+			return err
+		}
+
+		r.pool.AddBlock(envelope.From, block, block.Size())
+
+	case *bcproto.StatusRequest:
+		r.blockchainCh.Out <- p2p.Envelope{
+			To: envelope.From,
+			Message: &bcproto.StatusResponse{
+				Height: r.store.Height(),
+				Base:   r.store.Base(),
+			},
+		}
+
+	case *bcproto.StatusResponse:
+		r.pool.SetPeerRange(envelope.From, msg.Base, msg.Height)
+
+	case *bcproto.NoBlockResponse:
+		logger.Debug("peer does not have the requested block", "height", msg.Height)
+
+	default:
+		return fmt.Errorf("received unknown message: %T", msg)
+	}
+
+	return nil
+}
+
+// handleMessage handles an Envelope sent from a peer on a specific p2p Channel.
+// It will handle errors and any possible panics gracefully. A caller can handle
+// any error returned by sending a PeerError on the respective channel.
+func (r *Reactor) handleMessage(chID p2p.ChannelID, envelope p2p.Envelope) (err error) {
+	defer func() {
+		if e := recover(); e != nil {
+			err = fmt.Errorf("panic in processing message: %v", e)
+			r.Logger.Error("recovering from processing message panic", "err", err)
+		}
+	}()
+
+	r.Logger.Debug("received message", "message", envelope.Message, "peer", envelope.From)
+
+	switch chID {
+	case BlockchainChannel:
+		err = r.handleBlockchainMessage(envelope)
+
+	default:
+		err = fmt.Errorf("unknown channel ID (%d) for envelope (%v)", chID, envelope)
+	}
+
+	return err
+}
+
+// processBlockchainCh initiates a blocking process where we listen for and handle
+// envelopes on the BlockchainChannel. Any error encountered during message
+// execution will result in a PeerError being sent on the BlockchainChannel. When
+// the reactor is stopped, we will catch the signal and close the p2p Channel
+// gracefully.
+func (r *Reactor) processBlockchainCh() {
+	defer r.blockchainCh.Close()
+
+	for {
+		select {
+		case envelope := <-r.blockchainCh.In:
+			if err := r.handleMessage(r.blockchainCh.ID, envelope); err != nil {
+				r.Logger.Error("failed to process message", "ch_id", r.blockchainCh.ID, "envelope", envelope, "err", err)
+				r.blockchainCh.Error <- p2p.PeerError{
+					NodeID: envelope.From,
+					Err:    err,
+				}
+			}
+
+		case <-r.closeCh:
+			r.Logger.Debug("stopped listening on blockchain channel; closing...")
+			return
+		}
+	}
+}
+
+// processPeerUpdate processes a PeerUpdate.
+func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
+	r.Logger.Debug("received peer update", "peer", peerUpdate.NodeID, "status", peerUpdate.Status)
+
+	// XXX: Pool#RedoRequest can sometimes give us an empty peer.
+	if len(peerUpdate.NodeID) == 0 {
+		return
+	}
+
+	switch peerUpdate.Status {
+	case p2p.PeerStatusUp:
+		// send a status update the newly added peer
+		r.blockchainCh.Out <- p2p.Envelope{
+			To: peerUpdate.NodeID,
+			Message: &bcproto.StatusResponse{
+				Base:   r.store.Base(),
+				Height: r.store.Height(),
+			},
+		}
+
+	case p2p.PeerStatusDown:
+		r.pool.RemovePeer(peerUpdate.NodeID)
+	}
+}
+
+// processPeerUpdates initiates a blocking process where we listen for and handle
+// PeerUpdate messages. When the reactor is stopped, we will catch the signal and
+// close the p2p PeerUpdatesCh gracefully.
+func (r *Reactor) processPeerUpdates() {
+	defer r.peerUpdates.Close()
+
+	for {
+		select {
+		case peerUpdate := <-r.peerUpdates.Updates():
+			r.processPeerUpdate(peerUpdate)
+
+		case <-r.closeCh:
+			r.Logger.Debug("stopped listening on peer updates channel; closing...")
+			return
+		}
+	}
+}
+
+// SwitchToFastSync is called by the state sync reactor when switching to fast
+// sync.
+func (r *Reactor) SwitchToFastSync(state sm.State) error {
+	r.fastSync = true
+	r.initialState = state
+	r.pool.height = state.LastBlockHeight + 1
+
+	if err := r.pool.Start(); err != nil {
+		return err
+	}
+
+	r.poolWG.Add(1)
+	go r.poolRoutine(true)
+
+	return nil
+}
+
+func (r *Reactor) requestRoutine() {
+	statusUpdateTicker := time.NewTicker(statusUpdateIntervalSeconds * time.Second)
+	defer statusUpdateTicker.Stop()
+
+	r.poolWG.Add(1)
+	defer r.poolWG.Done()
+
+	for {
+		select {
+		case <-r.closeCh:
+			return
+
+		case <-r.pool.Quit():
+			return
+
+		case request := <-r.requestsCh:
+			r.blockchainCh.Out <- p2p.Envelope{
+				To:      request.PeerID,
+				Message: &bcproto.BlockRequest{Height: request.Height},
+			}
+
+		case pErr := <-r.errorsCh:
+			r.blockchainCh.Error <- p2p.PeerError{
+				NodeID: pErr.peerID,
+				Err:    pErr.err,
+			}
+
+		case <-statusUpdateTicker.C:
+			r.poolWG.Add(1)
+
+			go func() {
+				defer r.poolWG.Done()
+
+				r.blockchainCh.Out <- p2p.Envelope{
+					Broadcast: true,
+					Message:   &bcproto.StatusRequest{},
+				}
+			}()
+		}
+	}
+}
+
+// poolRoutine handles messages from the poolReactor telling the reactor what to
+// do.
+//
+// NOTE: Don't sleep in the FOR_LOOP or otherwise slow it down!
+func (r *Reactor) poolRoutine(stateSynced bool) {
+	var (
+		trySyncTicker           = time.NewTicker(trySyncIntervalMS * time.Millisecond)
+		switchToConsensusTicker = time.NewTicker(switchToConsensusIntervalSeconds * time.Second)
+
+		blocksSynced = uint64(0)
+
+		chainID = r.initialState.ChainID
+		state   = r.initialState
+
+		lastHundred = time.Now()
+		lastRate    = 0.0
+
+		didProcessCh = make(chan struct{}, 1)
+	)
+
+	defer trySyncTicker.Stop()
+	defer switchToConsensusTicker.Stop()
+
+	go r.requestRoutine()
+
+	defer r.poolWG.Done()
+
+FOR_LOOP:
+	for {
+		select {
+		case <-switchToConsensusTicker.C:
+			var (
+				height, numPending, lenRequesters = r.pool.GetStatus()
+				lastAdvance                       = r.pool.LastAdvance()
+			)
+
+			r.Logger.Debug(
+				"consensus ticker",
+				"num_pending", numPending,
+				"total", lenRequesters,
+				"height", height,
+			)
+
+			switch {
+			case r.pool.IsCaughtUp():
+				r.Logger.Info("switching to consensus reactor", "height", height)
+
+			case time.Since(lastAdvance) > syncTimeout:
+				r.Logger.Error("no progress since last advance", "last_advance", lastAdvance)
+
+			default:
+				r.Logger.Info(
+					"not caught up yet",
+					"height", height,
+					"max_peer_height", r.pool.MaxPeerHeight(),
+					"timeout_in", syncTimeout-time.Since(lastAdvance),
+				)
+				continue
+			}
+
+			if err := r.pool.Stop(); err != nil {
+				r.Logger.Error("failed to stop pool", "err", err)
+			}
+
+			if r.consReactor != nil {
+				r.consReactor.SwitchToConsensus(state, blocksSynced > 0 || stateSynced)
+			}
+
+			break FOR_LOOP
+
+		case <-trySyncTicker.C:
+			select {
+			case didProcessCh <- struct{}{}:
+			default:
+			}
+
+		case <-didProcessCh:
+			// NOTE: It is a subtle mistake to process more than a single block at a
+			// time (e.g. 10) here, because we only send one BlockRequest per loop
+			// iteration. The ratio mismatch can result in starving of blocks, i.e. a
+			// sudden burst of requests and responses, and repeat. Consequently, it is
+			// better to split these routines rather than coupling them as it is
+			// written here.
+			//
+			// TODO: Uncouple from request routine.
+
+			// see if there are any blocks to sync
+			first, second := r.pool.PeekTwoBlocks()
+			if first == nil || second == nil {
+				// we need both to sync the first block
+				continue FOR_LOOP
+			} else {
+				// try again quickly next loop
+				didProcessCh <- struct{}{}
+			}
+
+			var (
+				firstParts         = first.MakePartSet(types.BlockPartSizeBytes)
+				firstPartSetHeader = firstParts.Header()
+				firstID            = types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
+			)
+
+			// Finally, verify the first block using the second's commit.
+			//
+			// NOTE: We can probably make this more efficient, but note that calling
+			// first.Hash() doesn't verify the tx contents, so MakePartSet() is
+			// currently necessary.
+			err := state.Validators.VerifyCommitLight(chainID, firstID, first.Height, second.LastCommit)
+			if err != nil {
+				err = fmt.Errorf("invalid last commit: %w", err)
+				r.Logger.Error(
+					err.Error(),
+					"last_commit", second.LastCommit,
+					"block_id", firstID,
+					"height", first.Height,
+				)
+
+				// NOTE: We've already removed the peer's request, but we still need
+				// to clean up the rest.
+				peerID := r.pool.RedoRequest(first.Height)
+				r.blockchainCh.Error <- p2p.PeerError{
+					NodeID: peerID,
+					Err:    err,
+				}
+
+				peerID2 := r.pool.RedoRequest(second.Height)
+				if peerID2 != peerID {
+					r.blockchainCh.Error <- p2p.PeerError{
+						NodeID: peerID2,
+						Err:    err,
+					}
+				}
+
+				continue FOR_LOOP
+			} else {
+				r.pool.PopRequest()
+
+				// TODO: batch saves so we do not persist to disk every block
+				r.store.SaveBlock(first, firstParts, second.LastCommit)
+
+				var err error
+
+				// TODO: Same thing for app - but we would need a way to get the hash
+				// without persisting the state.
+				state, _, err = r.blockExec.ApplyBlock(state, firstID, first)
+				if err != nil {
+					// TODO: This is bad, are we zombie?
+					panic(fmt.Sprintf("failed to process committed block (%d:%X): %v", first.Height, first.Hash(), err))
+				}
+
+				blocksSynced++
+
+				if blocksSynced%100 == 0 {
+					lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
+					r.Logger.Info(
+						"fast sync rate",
+						"height", r.pool.height,
+						"max_peer_height", r.pool.MaxPeerHeight(),
+						"blocks/s", lastRate,
+					)
+
+					lastHundred = time.Now()
+				}
+			}
+
+			continue FOR_LOOP
+
+		case <-r.closeCh:
+			break FOR_LOOP
+		}
+	}
+}

blockchain/v0/reactor_test.go

@@ -0,0 +1,333 @@
+package v0
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	abci "github.com/tendermint/tendermint/abci/types"
+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/internal/test/factory"
+	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tendermint/tendermint/mempool/mock"
+	"github.com/tendermint/tendermint/p2p"
+	"github.com/tendermint/tendermint/p2p/p2ptest"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	"github.com/tendermint/tendermint/proxy"
+	sm "github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/store"
+	"github.com/tendermint/tendermint/types"
+	dbm "github.com/tendermint/tm-db"
+)
+
+type reactorTestSuite struct {
+	network *p2ptest.Network
+	logger  log.Logger
+	nodes   []p2p.NodeID
+
+	reactors map[p2p.NodeID]*Reactor
+	app      map[p2p.NodeID]proxy.AppConns
+
+	blockchainChannels map[p2p.NodeID]*p2p.Channel
+	peerChans          map[p2p.NodeID]chan p2p.PeerUpdate
+	peerUpdates        map[p2p.NodeID]*p2p.PeerUpdates
+
+	fastSync bool
+}
+
+func setup(
+	t *testing.T,
+	genDoc *types.GenesisDoc,
+	privVal types.PrivValidator,
+	maxBlockHeights []int64,
+	chBuf uint,
+) *reactorTestSuite {
+	t.Helper()
+
+	numNodes := len(maxBlockHeights)
+	require.True(t, numNodes >= 1,
+		"must specify at least one block height (nodes)")
+
+	rts := &reactorTestSuite{
+		logger:             log.TestingLogger().With("module", "blockchain", "testCase", t.Name()),
+		network:            p2ptest.MakeNetwork(t, p2ptest.NetworkOptions{NumNodes: numNodes}),
+		nodes:              make([]p2p.NodeID, 0, numNodes),
+		reactors:           make(map[p2p.NodeID]*Reactor, numNodes),
+		app:                make(map[p2p.NodeID]proxy.AppConns, numNodes),
+		blockchainChannels: make(map[p2p.NodeID]*p2p.Channel, numNodes),
+		peerChans:          make(map[p2p.NodeID]chan p2p.PeerUpdate, numNodes),
+		peerUpdates:        make(map[p2p.NodeID]*p2p.PeerUpdates, numNodes),
+		fastSync:           true,
+	}
+
+	chDesc := p2p.ChannelDescriptor{ID: byte(BlockchainChannel)}
+	rts.blockchainChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(bcproto.Message), int(chBuf))
+
+	i := 0
+	for nodeID := range rts.network.Nodes {
+		rts.addNode(t, nodeID, genDoc, privVal, maxBlockHeights[i])
+		i++
+	}
+
+	t.Cleanup(func() {
+		for _, nodeID := range rts.nodes {
+			rts.peerUpdates[nodeID].Close()
+
+			if rts.reactors[nodeID].IsRunning() {
+				require.NoError(t, rts.reactors[nodeID].Stop())
+				require.NoError(t, rts.app[nodeID].Stop())
+				require.False(t, rts.reactors[nodeID].IsRunning())
+			}
+		}
+	})
+
+	return rts
+}
+
+func (rts *reactorTestSuite) addNode(t *testing.T,
+	nodeID p2p.NodeID,
+	genDoc *types.GenesisDoc,
+	privVal types.PrivValidator,
+	maxBlockHeight int64,
+) {
+	t.Helper()
+
+	rts.nodes = append(rts.nodes, nodeID)
+	rts.app[nodeID] = proxy.NewAppConns(proxy.NewLocalClientCreator(&abci.BaseApplication{}))
+	require.NoError(t, rts.app[nodeID].Start())
+
+	blockDB := dbm.NewMemDB()
+	stateDB := dbm.NewMemDB()
+	stateStore := sm.NewStore(stateDB)
+	blockStore := store.NewBlockStore(blockDB)
+
+	state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+	require.NoError(t, err)
+
+	db := dbm.NewMemDB()
+	stateStore = sm.NewStore(db)
+
+	blockExec := sm.NewBlockExecutor(
+		stateStore,
+		log.TestingLogger(),
+		rts.app[nodeID].Consensus(),
+		mock.Mempool{},
+		sm.EmptyEvidencePool{},
+	)
+	require.NoError(t, stateStore.Save(state))
+
+	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
+		lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
+
+		if blockHeight > 1 {
+			lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
+			lastBlock := blockStore.LoadBlock(blockHeight - 1)
+
+			vote, err := factory.MakeVote(
+				privVal,
+				lastBlock.Header.ChainID, 0,
+				lastBlock.Header.Height, 0, 2,
+				lastBlockMeta.BlockID,
+				time.Now(),
+			)
+			require.NoError(t, err)
+
+			lastCommit = types.NewCommit(
+				vote.Height,
+				vote.Round,
+				lastBlockMeta.BlockID,
+				[]types.CommitSig{vote.CommitSig()},
+			)
+		}
+
+		thisBlock := makeBlock(blockHeight, state, lastCommit)
+		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
+		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
+
+		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
+		require.NoError(t, err)
+
+		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
+	}
+
+	rts.peerChans[nodeID] = make(chan p2p.PeerUpdate)
+	rts.peerUpdates[nodeID] = p2p.NewPeerUpdates(rts.peerChans[nodeID], 1)
+	rts.network.Nodes[nodeID].PeerManager.Register(rts.peerUpdates[nodeID])
+	rts.reactors[nodeID], err = NewReactor(
+		rts.logger.With("nodeID", nodeID),
+		state.Copy(),
+		blockExec,
+		blockStore,
+		nil,
+		rts.blockchainChannels[nodeID],
+		rts.peerUpdates[nodeID],
+		rts.fastSync)
+	require.NoError(t, err)
+
+	require.NoError(t, rts.reactors[nodeID].Start())
+	require.True(t, rts.reactors[nodeID].IsRunning())
+}
+
+func (rts *reactorTestSuite) start(t *testing.T) {
+	t.Helper()
+	rts.network.Start(t)
+	require.Len(t,
+		rts.network.RandomNode().PeerManager.Peers(),
+		len(rts.nodes)-1,
+		"network does not have expected number of nodes")
+}
+
+func TestReactor_AbruptDisconnect(t *testing.T) {
+	config := cfg.ResetTestRoot("blockchain_reactor_test")
+	defer os.RemoveAll(config.RootDir)
+
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
+	maxBlockHeight := int64(64)
+
+	rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
+
+	require.Equal(t, maxBlockHeight, rts.reactors[rts.nodes[0]].store.Height())
+
+	rts.start(t)
+
+	secondaryPool := rts.reactors[rts.nodes[1]].pool
+
+	require.Eventually(
+		t,
+		func() bool {
+			height, _, _ := secondaryPool.GetStatus()
+			return secondaryPool.MaxPeerHeight() > 0 && height > 0 && height < 10
+		},
+		10*time.Second,
+		10*time.Millisecond,
+		"expected node to be partially synced",
+	)
+
+	// Remove synced node from the syncing node which should not result in any
+	// deadlocks or race conditions within the context of poolRoutine.
+	rts.peerChans[rts.nodes[1]] <- p2p.PeerUpdate{
+		Status: p2p.PeerStatusDown,
+		NodeID: rts.nodes[0],
+	}
+	require.NoError(t, rts.network.Nodes[rts.nodes[1]].PeerManager.Disconnected(rts.nodes[0]))
+}
+
+func TestReactor_NoBlockResponse(t *testing.T) {
+	config := cfg.ResetTestRoot("blockchain_reactor_test")
+	defer os.RemoveAll(config.RootDir)
+
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
+	maxBlockHeight := int64(65)
+
+	rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
+
+	require.Equal(t, maxBlockHeight, rts.reactors[rts.nodes[0]].store.Height())
+
+	rts.start(t)
+
+	testCases := []struct {
+		height   int64
+		existent bool
+	}{
+		{maxBlockHeight + 2, false},
+		{10, true},
+		{1, true},
+		{100, false},
+	}
+
+	secondaryPool := rts.reactors[rts.nodes[1]].pool
+	require.Eventually(
+		t,
+		func() bool { return secondaryPool.MaxPeerHeight() > 0 && secondaryPool.IsCaughtUp() },
+		10*time.Second,
+		10*time.Millisecond,
+		"expected node to be fully synced",
+	)
+
+	for _, tc := range testCases {
+		block := rts.reactors[rts.nodes[1]].store.LoadBlock(tc.height)
+		if tc.existent {
+			require.True(t, block != nil)
+		} else {
+			require.Nil(t, block)
+		}
+	}
+}
+
+func TestReactor_BadBlockStopsPeer(t *testing.T) {
+	// Ultimately, this should be refactored to be less integration test oriented
+	// and more unit test oriented by simply testing channel sends and receives.
+	// See: https://github.com/tendermint/tendermint/issues/6005
+	t.SkipNow()
+
+	config := cfg.ResetTestRoot("blockchain_reactor_test")
+	defer os.RemoveAll(config.RootDir)
+
+	maxBlockHeight := int64(48)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
+
+	rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0, 0, 0, 0}, 1000)
+
+	require.Equal(t, maxBlockHeight, rts.reactors[rts.nodes[0]].store.Height())
+
+	rts.start(t)
+
+	require.Eventually(
+		t,
+		func() bool {
+			caughtUp := true
+			for _, id := range rts.nodes[1 : len(rts.nodes)-1] {
+				if rts.reactors[id].pool.MaxPeerHeight() == 0 || !rts.reactors[id].pool.IsCaughtUp() {
+					caughtUp = false
+				}
+			}
+
+			return caughtUp
+		},
+		10*time.Minute,
+		10*time.Millisecond,
+		"expected all nodes to be fully synced",
+	)
+
+	for _, id := range rts.nodes[:len(rts.nodes)-1] {
+		require.Len(t, rts.reactors[id].pool.peers, 3)
+	}
+
+	// Mark testSuites[3] as an invalid peer which will cause newSuite to disconnect
+	// from this peer.
+	//
+	// XXX: This causes a potential race condition.
+	// See: https://github.com/tendermint/tendermint/issues/6005
+	otherGenDoc, otherPrivVals := factory.RandGenesisDoc(config, 1, false, 30)
+	newNode := rts.network.MakeNode(t, p2ptest.NodeOptions{
+		MaxPeers:     uint16(len(rts.nodes) + 1),
+		MaxConnected: uint16(len(rts.nodes) + 1),
+	})
+	rts.addNode(t, newNode.NodeID, otherGenDoc, otherPrivVals[0], maxBlockHeight)
+
+	// add a fake peer just so we do not wait for the consensus ticker to timeout
+	rts.reactors[newNode.NodeID].pool.SetPeerRange("00ff", 10, 10)
+
+	// wait for the new peer to catch up and become fully synced
+	require.Eventually(
+		t,
+		func() bool {
+			return rts.reactors[newNode.NodeID].pool.MaxPeerHeight() > 0 && rts.reactors[newNode.NodeID].pool.IsCaughtUp()
+		},
+		10*time.Minute,
+		10*time.Millisecond,
+		"expected new node to be fully synced",
+	)
+
+	require.Eventuallyf(
+		t,
+		func() bool { return len(rts.reactors[newNode.NodeID].pool.peers) < len(rts.nodes)-1 },
+		10*time.Minute,
+		10*time.Millisecond,
+		"invalid number of peers; expected < %d, got: %d",
+		len(rts.nodes)-1,
+		len(rts.reactors[newNode.NodeID].pool.peers),
+	)
+}

blockchain/v0/test_util.go

@@ -0,0 +1,18 @@
+package v0
+
+import (
+	sm "github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/types"
+)
+
+func makeTxs(height int64) (txs []types.Tx) {
+	for i := 0; i < 10; i++ {
+		txs = append(txs, types.Tx([]byte{byte(height), byte(i)}))
+	}
+	return txs
+}
+
+func makeBlock(height int64, state sm.State, lastCommit *types.Commit) *types.Block {
+	block, _ := state.MakeBlock(height, makeTxs(height), lastCommit, nil, state.Validators.GetProposer().Address)
+	return block
+}

blockchain/v2/internal/behavior/doc.go

@@ -1,10 +1,10 @@
 /*
-Package Behaviour provides a mechanism for reactors to report behaviour of peers.
+Package Behavior provides a mechanism for reactors to report behavior of peers.
 
-Instead of a reactor calling the switch directly it will call the behaviour module which will
+Instead of a reactor calling the switch directly it will call the behavior module which will
 handle the stoping and marking peer as good on behalf of the reactor.
 
-There are four different behaviours a reactor can report.
+There are four different behaviors a reactor can report.
 
 1. bad message
 
@@ -39,4 +39,4 @@ type blockPart struct {
 This message will request the peer be marked as good
 
 */
-package behaviour
+package behavior

blockchain/v2/internal/behavior/peer_behaviour.go

@@ -0,0 +1,49 @@
+package behavior
+
+import (
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// PeerBehavior is a struct describing a behavior a peer performed.
+// `peerID` identifies the peer and reason characterizes the specific
+// behavior performed by the peer.
+type PeerBehavior struct {
+	peerID p2p.NodeID
+	reason interface{}
+}
+
+type badMessage struct {
+	explanation string
+}
+
+// BadMessage returns a badMessage PeerBehavior.
+func BadMessage(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: badMessage{explanation}}
+}
+
+type messageOutOfOrder struct {
+	explanation string
+}
+
+// MessageOutOfOrder returns a messagOutOfOrder PeerBehavior.
+func MessageOutOfOrder(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: messageOutOfOrder{explanation}}
+}
+
+type consensusVote struct {
+	explanation string
+}
+
+// ConsensusVote returns a consensusVote PeerBehavior.
+func ConsensusVote(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: consensusVote{explanation}}
+}
+
+type blockPart struct {
+	explanation string
+}
+
+// BlockPart returns blockPart PeerBehavior.
+func BlockPart(peerID p2p.NodeID, explanation string) PeerBehavior {
+	return PeerBehavior{peerID: peerID, reason: blockPart{explanation}}
+}

blockchain/v2/internal/behavior/reporter.go

@@ -1,4 +1,4 @@
-package behaviour
+package behavior
 
 import (
 	"errors"
@@ -7,13 +7,13 @@ import (
 	"github.com/tendermint/tendermint/p2p"
 )
 
-// Reporter provides an interface for reactors to report the behaviour
+// Reporter provides an interface for reactors to report the behavior
 // of peers synchronously to other components.
 type Reporter interface {
-	Report(behaviour PeerBehaviour) error
+	Report(behavior PeerBehavior) error
 }
 
-// SwitchReporter reports peer behaviour to an internal Switch.
+// SwitchReporter reports peer behavior to an internal Switch.
 type SwitchReporter struct {
 	sw *p2p.Switch
 }
@@ -25,14 +25,14 @@ func NewSwitchReporter(sw *p2p.Switch) *SwitchReporter {
 	}
 }
 
-// Report reports the behaviour of a peer to the Switch.
-func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {
-	peer := spbr.sw.Peers().Get(behaviour.peerID)
+// Report reports the behavior of a peer to the Switch.
+func (spbr *SwitchReporter) Report(behavior PeerBehavior) error {
+	peer := spbr.sw.Peers().Get(behavior.peerID)
 	if peer == nil {
 		return errors.New("peer not found")
 	}
 
-	switch reason := behaviour.reason.(type) {
+	switch reason := behavior.reason.(type) {
 	case consensusVote, blockPart:
 		spbr.sw.MarkPeerAsGood(peer)
 	case badMessage:
@@ -48,39 +48,39 @@ func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {
 
 // MockReporter is a concrete implementation of the Reporter
 // interface used in reactor tests to ensure reactors report the correct
-// behaviour in manufactured scenarios.
+// behavior in manufactured scenarios.
 type MockReporter struct {
 	mtx tmsync.RWMutex
-	pb  map[p2p.ID][]PeerBehaviour
+	pb  map[p2p.NodeID][]PeerBehavior
 }
 
 // NewMockReporter returns a Reporter which records all reported
-// behaviours in memory.
+// behaviors in memory.
 func NewMockReporter() *MockReporter {
 	return &MockReporter{
-		pb: map[p2p.ID][]PeerBehaviour{},
+		pb: map[p2p.NodeID][]PeerBehavior{},
 	}
 }
 
-// Report stores the PeerBehaviour produced by the peer identified by peerID.
-func (mpbr *MockReporter) Report(behaviour PeerBehaviour) error {
+// Report stores the PeerBehavior produced by the peer identified by peerID.
+func (mpbr *MockReporter) Report(behavior PeerBehavior) error {
 	mpbr.mtx.Lock()
 	defer mpbr.mtx.Unlock()
-	mpbr.pb[behaviour.peerID] = append(mpbr.pb[behaviour.peerID], behaviour)
+	mpbr.pb[behavior.peerID] = append(mpbr.pb[behavior.peerID], behavior)
 
 	return nil
 }
 
-// GetBehaviours returns all behaviours reported on the peer identified by peerID.
-func (mpbr *MockReporter) GetBehaviours(peerID p2p.ID) []PeerBehaviour {
+// GetBehaviors returns all behaviors reported on the peer identified by peerID.
+func (mpbr *MockReporter) GetBehaviors(peerID p2p.NodeID) []PeerBehavior {
 	mpbr.mtx.RLock()
 	defer mpbr.mtx.RUnlock()
 	if items, ok := mpbr.pb[peerID]; ok {
-		result := make([]PeerBehaviour, len(items))
+		result := make([]PeerBehavior, len(items))
 		copy(result, items)
 
 		return result
 	}
 
-	return []PeerBehaviour{}
+	return []PeerBehavior{}
 }

blockchain/v2/internal/behavior/reporter_test.go

@@ -0,0 +1,205 @@
+package behavior_test
+
+import (
+	"sync"
+	"testing"
+
+	bh "github.com/tendermint/tendermint/blockchain/v2/internal/behavior"
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// TestMockReporter tests the MockReporter's ability to store reported
+// peer behavior in memory indexed by the peerID.
+func TestMockReporter(t *testing.T) {
+	var peerID p2p.NodeID = "MockPeer"
+	pr := bh.NewMockReporter()
+
+	behaviors := pr.GetBehaviors(peerID)
+	if len(behaviors) != 0 {
+		t.Error("Expected to have no behaviors reported")
+	}
+
+	badMessage := bh.BadMessage(peerID, "bad message")
+	if err := pr.Report(badMessage); err != nil {
+		t.Error(err)
+	}
+	behaviors = pr.GetBehaviors(peerID)
+	if len(behaviors) != 1 {
+		t.Error("Expected the peer have one reported behavior")
+	}
+
+	if behaviors[0] != badMessage {
+		t.Error("Expected Bad Message to have been reported")
+	}
+}
+
+type scriptItem struct {
+	peerID   p2p.NodeID
+	behavior bh.PeerBehavior
+}
+
+// equalBehaviors returns true if a and b contain the same PeerBehaviors with
+// the same freequencies and otherwise false.
+func equalBehaviors(a []bh.PeerBehavior, b []bh.PeerBehavior) bool {
+	aHistogram := map[bh.PeerBehavior]int{}
+	bHistogram := map[bh.PeerBehavior]int{}
+
+	for _, behavior := range a {
+		aHistogram[behavior]++
+	}
+
+	for _, behavior := range b {
+		bHistogram[behavior]++
+	}
+
+	if len(aHistogram) != len(bHistogram) {
+		return false
+	}
+
+	for _, behavior := range a {
+		if aHistogram[behavior] != bHistogram[behavior] {
+			return false
+		}
+	}
+
+	for _, behavior := range b {
+		if bHistogram[behavior] != aHistogram[behavior] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// TestEqualPeerBehaviors tests that equalBehaviors can tell that two slices
+// of peer behaviors can be compared for the behaviors they contain and the
+// freequencies that those behaviors occur.
+func TestEqualPeerBehaviors(t *testing.T) {
+	var (
+		peerID        p2p.NodeID = "MockPeer"
+		consensusVote            = bh.ConsensusVote(peerID, "voted")
+		blockPart                = bh.BlockPart(peerID, "blocked")
+		equals                   = []struct {
+			left  []bh.PeerBehavior
+			right []bh.PeerBehavior
+		}{
+			// Empty sets
+			{[]bh.PeerBehavior{}, []bh.PeerBehavior{}},
+			// Single behaviors
+			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{consensusVote}},
+			// Equal Frequencies
+			{[]bh.PeerBehavior{consensusVote, consensusVote},
+				[]bh.PeerBehavior{consensusVote, consensusVote}},
+			// Equal frequencies different orders
+			{[]bh.PeerBehavior{consensusVote, blockPart},
+				[]bh.PeerBehavior{blockPart, consensusVote}},
+		}
+		unequals = []struct {
+			left  []bh.PeerBehavior
+			right []bh.PeerBehavior
+		}{
+			// Comparing empty sets to non empty sets
+			{[]bh.PeerBehavior{}, []bh.PeerBehavior{consensusVote}},
+			// Different behaviors
+			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{blockPart}},
+			// Same behavior with different frequencies
+			{[]bh.PeerBehavior{consensusVote},
+				[]bh.PeerBehavior{consensusVote, consensusVote}},
+		}
+	)
+
+	for _, test := range equals {
+		if !equalBehaviors(test.left, test.right) {
+			t.Errorf("expected %#v and %#v to be equal", test.left, test.right)
+		}
+	}
+
+	for _, test := range unequals {
+		if equalBehaviors(test.left, test.right) {
+			t.Errorf("expected %#v and %#v to be unequal", test.left, test.right)
+		}
+	}
+}
+
+// TestPeerBehaviorConcurrency constructs a scenario in which
+// multiple goroutines are using the same MockReporter instance.
+// This test reproduces the conditions in which MockReporter will
+// be used within a Reactor `Receive` method tests to ensure thread safety.
+func TestMockPeerBehaviorReporterConcurrency(t *testing.T) {
+	var (
+		behaviorScript = []struct {
+			peerID    p2p.NodeID
+			behaviors []bh.PeerBehavior
+		}{
+			{"1", []bh.PeerBehavior{bh.ConsensusVote("1", "")}},
+			{"2", []bh.PeerBehavior{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
+			{
+				"3",
+				[]bh.PeerBehavior{bh.BlockPart("3", ""),
+					bh.ConsensusVote("3", ""),
+					bh.BlockPart("3", ""),
+					bh.ConsensusVote("3", "")}},
+			{
+				"4",
+				[]bh.PeerBehavior{bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", ""),
+					bh.ConsensusVote("4", "")}},
+			{
+				"5",
+				[]bh.PeerBehavior{bh.BlockPart("5", ""),
+					bh.ConsensusVote("5", ""),
+					bh.BlockPart("5", ""),
+					bh.ConsensusVote("5", "")}},
+		}
+	)
+
+	var receiveWg sync.WaitGroup
+	pr := bh.NewMockReporter()
+	scriptItems := make(chan scriptItem)
+	done := make(chan int)
+	numConsumers := 3
+	for i := 0; i < numConsumers; i++ {
+		receiveWg.Add(1)
+		go func() {
+			defer receiveWg.Done()
+			for {
+				select {
+				case pb := <-scriptItems:
+					if err := pr.Report(pb.behavior); err != nil {
+						t.Error(err)
+					}
+				case <-done:
+					return
+				}
+			}
+		}()
+	}
+
+	var sendingWg sync.WaitGroup
+	sendingWg.Add(1)
+	go func() {
+		defer sendingWg.Done()
+		for _, item := range behaviorScript {
+			for _, reason := range item.behaviors {
+				scriptItems <- scriptItem{item.peerID, reason}
+			}
+		}
+	}()
+
+	sendingWg.Wait()
+
+	for i := 0; i < numConsumers; i++ {
+		done <- 1
+	}
+
+	receiveWg.Wait()
+
+	for _, items := range behaviorScript {
+		reported := pr.GetBehaviors(items.peerID)
+		if !equalBehaviors(reported, items.behaviors) {
+			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
+				items.peerID, items.behaviors, reported)
+		}
+	}
+}

blockchain/v2/io.go

@@ -0,0 +1,187 @@
+package v2
+
+import (
+	"errors"
+
+	"github.com/gogo/protobuf/proto"
+	"github.com/tendermint/tendermint/p2p"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	"github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/types"
+)
+
+var (
+	errPeerQueueFull = errors.New("peer queue full")
+)
+
+type iIO interface {
+	sendBlockRequest(peer p2p.Peer, height int64) error
+	sendBlockToPeer(block *types.Block, peer p2p.Peer) error
+	sendBlockNotFound(height int64, peer p2p.Peer) error
+	sendStatusResponse(base, height int64, peer p2p.Peer) error
+
+	sendStatusRequest(peer p2p.Peer) error
+	broadcastStatusRequest() error
+
+	trySwitchToConsensus(state state.State, skipWAL bool) bool
+}
+
+type switchIO struct {
+	sw *p2p.Switch
+}
+
+func newSwitchIo(sw *p2p.Switch) *switchIO {
+	return &switchIO{
+		sw: sw,
+	}
+}
+
+const (
+	// BlockchainChannel is a channel for blocks and status updates (`BlockStore` height)
+	BlockchainChannel = byte(0x40)
+)
+
+type consensusReactor interface {
+	// for when we switch from blockchain reactor and fast sync to
+	// the consensus machine
+	SwitchToConsensus(state state.State, skipWAL bool)
+}
+
+func (sio *switchIO) sendBlockRequest(peer p2p.Peer, height int64) error {
+	msgProto := &bcproto.Message{
+		Sum: &bcproto.Message_BlockRequest{
+			BlockRequest: &bcproto.BlockRequest{
+				Height: height,
+			},
+		},
+	}
+
+	msgBytes, err := proto.Marshal(msgProto)
+	if err != nil {
+		return err
+	}
+
+	queued := peer.TrySend(BlockchainChannel, msgBytes)
+	if !queued {
+		return errPeerQueueFull
+	}
+	return nil
+}
+
+func (sio *switchIO) sendStatusResponse(base int64, height int64, peer p2p.Peer) error {
+	msgProto := &bcproto.Message{
+		Sum: &bcproto.Message_StatusResponse{
+			StatusResponse: &bcproto.StatusResponse{
+				Height: height,
+				Base:   base,
+			},
+		},
+	}
+
+	msgBytes, err := proto.Marshal(msgProto)
+	if err != nil {
+		return err
+	}
+
+	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
+		return errPeerQueueFull
+	}
+
+	return nil
+}
+
+func (sio *switchIO) sendBlockToPeer(block *types.Block, peer p2p.Peer) error {
+	if block == nil {
+		panic("trying to send nil block")
+	}
+
+	bpb, err := block.ToProto()
+	if err != nil {
+		return err
+	}
+
+	msgProto := &bcproto.Message{
+		Sum: &bcproto.Message_BlockResponse{
+			BlockResponse: &bcproto.BlockResponse{
+				Block: bpb,
+			},
+		},
+	}
+
+	msgBytes, err := proto.Marshal(msgProto)
+	if err != nil {
+		return err
+	}
+
+	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
+		return errPeerQueueFull
+	}
+
+	return nil
+}
+
+func (sio *switchIO) sendBlockNotFound(height int64, peer p2p.Peer) error {
+	msgProto := &bcproto.Message{
+		Sum: &bcproto.Message_NoBlockResponse{
+			NoBlockResponse: &bcproto.NoBlockResponse{
+				Height: height,
+			},
+		},
+	}
+
+	msgBytes, err := proto.Marshal(msgProto)
+	if err != nil {
+		return err
+	}
+
+	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
+		return errPeerQueueFull
+	}
+
+	return nil
+}
+
+func (sio *switchIO) trySwitchToConsensus(state state.State, skipWAL bool) bool {
+	conR, ok := sio.sw.Reactor("CONSENSUS").(consensusReactor)
+	if ok {
+		conR.SwitchToConsensus(state, skipWAL)
+	}
+	return ok
+}
+
+func (sio *switchIO) sendStatusRequest(peer p2p.Peer) error {
+	msgProto := &bcproto.Message{
+		Sum: &bcproto.Message_StatusRequest{
+			StatusRequest: &bcproto.StatusRequest{},
+		},
+	}
+
+	msgBytes, err := proto.Marshal(msgProto)
+	if err != nil {
+		return err
+	}
+
+	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
+		return errPeerQueueFull
+	}
+
+	return nil
+}
+
+func (sio *switchIO) broadcastStatusRequest() error {
+	msgProto := &bcproto.Message{
+		Sum: &bcproto.Message_StatusRequest{
+			StatusRequest: &bcproto.StatusRequest{},
+		},
+	}
+
+	msgBytes, err := proto.Marshal(msgProto)
+	if err != nil {
+		return err
+	}
+
+	// XXX: maybe we should use an io specific peer list here
+	sio.sw.Broadcast(BlockchainChannel, msgBytes)
+
+	return nil
+}

blockchain/v2/processor.go

@@ -13,8 +13,8 @@ import (
 type pcBlockVerificationFailure struct {
 	priorityNormal
 	height       int64
-	firstPeerID  p2p.ID
-	secondPeerID p2p.ID
+	firstPeerID  p2p.NodeID
+	secondPeerID p2p.NodeID
 }
 
 func (e pcBlockVerificationFailure) String() string {
@@ -26,7 +26,7 @@ func (e pcBlockVerificationFailure) String() string {
 type pcBlockProcessed struct {
 	priorityNormal
 	height int64
-	peerID p2p.ID
+	peerID p2p.NodeID
 }
 
 func (e pcBlockProcessed) String() string {
@@ -46,7 +46,7 @@ func (p pcFinished) Error() string {
 
 type queueItem struct {
 	block  *types.Block
-	peerID p2p.ID
+	peerID p2p.NodeID
 }
 
 type blockQueue map[int64]queueItem
@@ -95,7 +95,7 @@ func (state *pcState) synced() bool {
 	return len(state.queue) <= 1
 }
 
-func (state *pcState) enqueue(peerID p2p.ID, block *types.Block, height int64) {
+func (state *pcState) enqueue(peerID p2p.NodeID, block *types.Block, height int64) {
 	if item, ok := state.queue[height]; ok {
 		panic(fmt.Sprintf(
 			"duplicate block %d (%X) enqueued by processor (sent by %v; existing block %X from %v)",
@@ -110,7 +110,7 @@ func (state *pcState) height() int64 {
 }
 
 // purgePeer moves all unprocessed blocks from the queue
-func (state *pcState) purgePeer(peerID p2p.ID) {
+func (state *pcState) purgePeer(peerID p2p.NodeID) {
 	// what if height is less than state.height?
 	for height, item := range state.queue {
 		if item.peerID == peerID {

blockchain/v2/processor_test.go

@@ -40,7 +40,7 @@ func makeState(p *params) *pcState {
 	state := newPcState(context)
 
 	for _, item := range p.items {
-		state.enqueue(p2p.ID(item.pid), makePcBlock(item.height), item.height)
+		state.enqueue(p2p.NodeID(item.pid), makePcBlock(item.height), item.height)
 	}
 
 	state.blocksSynced = p.blocksSynced
@@ -48,7 +48,7 @@ func makeState(p *params) *pcState {
 	return state
 }
 
-func mBlockResponse(peerID p2p.ID, height int64) scBlockReceived {
+func mBlockResponse(peerID p2p.NodeID, height int64) scBlockReceived {
 	return scBlockReceived{
 		peerID: peerID,
 		block:  makePcBlock(height),
@@ -82,7 +82,7 @@ func executeProcessorTests(t *testing.T, tests []testFields) {
 					}
 				}()
 
-				// First step must always initialise the currentState as state.
+				// First step must always initialize the currentState as state.
 				if step.currentState != nil {
 					state = makeState(step.currentState)
 				}

blockchain/v2/reactor.go

@@ -5,8 +5,10 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/tendermint/tendermint/behaviour"
+	proto "github.com/gogo/protobuf/proto"
+
 	bc "github.com/tendermint/tendermint/blockchain"
+	"github.com/tendermint/tendermint/blockchain/v2/internal/behavior"
 	"github.com/tendermint/tendermint/libs/log"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
 	"github.com/tendermint/tendermint/p2p"
@@ -42,22 +44,17 @@ type BlockchainReactor struct {
 	syncHeight    int64
 	events        chan Event // non-nil during a fast sync
 
-	reporter behaviour.Reporter
+	reporter behavior.Reporter
 	io       iIO
 	store    blockStore
 }
 
-//nolint:unused,deadcode
-type blockVerifier interface {
-	VerifyCommit(chainID string, blockID types.BlockID, height int64, commit *types.Commit) error
-}
-
 type blockApplier interface {
 	ApplyBlock(state state.State, blockID types.BlockID, block *types.Block) (state.State, int64, error)
 }
 
 // XXX: unify naming in this package around tmState
-func newReactor(state state.State, store blockStore, reporter behaviour.Reporter,
+func newReactor(state state.State, store blockStore, reporter behavior.Reporter,
 	blockApplier blockApplier, fastSync bool) *BlockchainReactor {
 	initHeight := state.LastBlockHeight + 1
 	if initHeight == 1 {
@@ -85,7 +82,7 @@ func NewBlockchainReactor(
 	blockApplier blockApplier,
 	store blockStore,
 	fastSync bool) *BlockchainReactor {
-	reporter := behaviour.NewMockReporter()
+	reporter := behavior.NewMockReporter()
 	return newReactor(state, store, reporter, blockApplier, fastSync)
 }
 
@@ -129,7 +126,7 @@ func (r *BlockchainReactor) SetLogger(logger log.Logger) {
 
 // Start implements cmn.Service interface
 func (r *BlockchainReactor) Start() error {
-	r.reporter = behaviour.NewSwitchReporter(r.BaseReactor.Switch)
+	r.reporter = behavior.NewSwitchReporter(r.BaseReactor.Switch)
 	if r.fastSync {
 		err := r.startSync(nil)
 		if err != nil {
@@ -139,7 +136,7 @@ func (r *BlockchainReactor) Start() error {
 	return nil
 }
 
-// startSync begins a fast sync, signalled by r.events being non-nil. If state is non-nil,
+// startSync begins a fast sync, signaled by r.events being non-nil. If state is non-nil,
 // the scheduler and processor is updated with this state on startup.
 func (r *BlockchainReactor) startSync(state *state.State) error {
 	r.mtx.Lock()
@@ -214,7 +211,7 @@ func (e rProcessBlock) String() string {
 type bcBlockResponse struct {
 	priorityNormal
 	time   time.Time
-	peerID p2p.ID
+	peerID p2p.NodeID
 	size   int64
 	block  *types.Block
 }
@@ -228,7 +225,7 @@ func (resp bcBlockResponse) String() string {
 type bcNoBlockResponse struct {
 	priorityNormal
 	time   time.Time
-	peerID p2p.ID
+	peerID p2p.NodeID
 	height int64
 }
 
@@ -241,7 +238,7 @@ func (resp bcNoBlockResponse) String() string {
 type bcStatusResponse struct {
 	priorityNormal
 	time   time.Time
-	peerID p2p.ID
+	peerID p2p.NodeID
 	base   int64
 	height int64
 }
@@ -254,7 +251,7 @@ func (resp bcStatusResponse) String() string {
 // new peer is connected
 type bcAddNewPeer struct {
 	priorityNormal
-	peerID p2p.ID
+	peerID p2p.NodeID
 }
 
 func (resp bcAddNewPeer) String() string {
@@ -264,7 +261,7 @@ func (resp bcAddNewPeer) String() string {
 // existing peer is removed
 type bcRemovePeer struct {
 	priorityHigh
-	peerID p2p.ID
+	peerID p2p.NodeID
 	reason interface{}
 }
 
@@ -316,6 +313,9 @@ func (r *BlockchainReactor) demux(events <-chan Event) {
 	defer doStatusTk.Stop()
 	doStatusCh <- struct{}{} // immediately broadcast to get status of existing peers
 
+	// Memoize the scSchedulerFail error to avoid printing it every scheduleFreq.
+	var scSchedulerFailErr error
+
 	// XXX: Extract timers to make testing atemporal
 	for {
 		select {
@@ -376,18 +376,26 @@ func (r *BlockchainReactor) demux(events <-chan Event) {
 				r.processor.send(event)
 			case scPeerError:
 				r.processor.send(event)
-				if err := r.reporter.Report(behaviour.BadMessage(event.peerID, "scPeerError")); err != nil {
+				if err := r.reporter.Report(behavior.BadMessage(event.peerID, "scPeerError")); err != nil {
 					r.logger.Error("Error reporting peer", "err", err)
 				}
 			case scBlockRequest:
-				if err := r.io.sendBlockRequest(event.peerID, event.height); err != nil {
+				peer := r.Switch.Peers().Get(event.peerID)
+				if peer == nil {
+					r.logger.Error("Wanted to send block request, but no such peer", "peerID", event.peerID)
+					continue
+				}
+				if err := r.io.sendBlockRequest(peer, event.height); err != nil {
 					r.logger.Error("Error sending block request", "err", err)
 				}
 			case scFinishedEv:
 				r.processor.send(event)
 				r.scheduler.stop()
 			case scSchedulerFail:
-				r.logger.Error("Scheduler failure", "err", event.reason.Error())
+				if scSchedulerFailErr != event.reason {
+					r.logger.Error("Scheduler failure", "err", event.reason.Error())
+					scSchedulerFailErr = event.reason
+				}
 			case scPeersPruned:
 				// Remove peers from the processor.
 				for _, peerID := range event.peers {
@@ -455,54 +463,62 @@ func (r *BlockchainReactor) Stop() error {
 }
 
 // Receive implements Reactor by handling different message types.
+// XXX: do not call any methods that can block or incur heavy processing.
+// https://github.com/tendermint/tendermint/issues/2888
 func (r *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
-	msg, err := bc.DecodeMsg(msgBytes)
-	if err != nil {
-		r.logger.Error("error decoding message",
-			"src", src.ID(), "chId", chID, "msg", msg, "err", err)
-		_ = r.reporter.Report(behaviour.BadMessage(src.ID(), err.Error()))
+	logger := r.logger.With("src", src.ID(), "chID", chID)
+
+	msgProto := new(bcproto.Message)
+
+	if err := proto.Unmarshal(msgBytes, msgProto); err != nil {
+		logger.Error("error decoding message", "err", err)
+		_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
 		return
 	}
 
-	if err = bc.ValidateMsg(msg); err != nil {
-		r.logger.Error("peer sent us invalid msg", "peer", src, "msg", msg, "err", err)
-		_ = r.reporter.Report(behaviour.BadMessage(src.ID(), err.Error()))
+	if err := msgProto.Validate(); err != nil {
+		logger.Error("peer sent us an invalid msg", "msg", msgProto, "err", err)
+		_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
 		return
 	}
 
-	r.logger.Debug("Receive", "src", src.ID(), "chID", chID, "msg", msg)
+	r.logger.Debug("received", "msg", msgProto)
 
-	switch msg := msg.(type) {
-	case *bcproto.StatusRequest:
-		if err := r.io.sendStatusResponse(r.store.Base(), r.store.Height(), src.ID()); err != nil {
-			r.logger.Error("Could not send status message to peer", "src", src)
+	switch msg := msgProto.Sum.(type) {
+	case *bcproto.Message_StatusRequest:
+		if err := r.io.sendStatusResponse(r.store.Base(), r.store.Height(), src); err != nil {
+			logger.Error("Could not send status message to src peer")
 		}
 
-	case *bcproto.BlockRequest:
-		block := r.store.LoadBlock(msg.Height)
+	case *bcproto.Message_BlockRequest:
+		block := r.store.LoadBlock(msg.BlockRequest.Height)
 		if block != nil {
-			if err = r.io.sendBlockToPeer(block, src.ID()); err != nil {
-				r.logger.Error("Could not send block message to peer: ", err)
+			if err := r.io.sendBlockToPeer(block, src); err != nil {
+				logger.Error("Could not send block message to src peer", "err", err)
 			}
 		} else {
-			r.logger.Info("peer asking for a block we don't have", "src", src, "height", msg.Height)
-			peerID := src.ID()
-			if err = r.io.sendBlockNotFound(msg.Height, peerID); err != nil {
-				r.logger.Error("Couldn't send block not found: ", err)
+			logger.Info("peer asking for a block we don't have", "height", msg.BlockRequest.Height)
+			if err := r.io.sendBlockNotFound(msg.BlockRequest.Height, src); err != nil {
+				logger.Error("Couldn't send block not found msg", "err", err)
 			}
 		}
 
-	case *bcproto.StatusResponse:
+	case *bcproto.Message_StatusResponse:
 		r.mtx.RLock()
 		if r.events != nil {
-			r.events <- bcStatusResponse{peerID: src.ID(), base: msg.Base, height: msg.Height}
+			r.events <- bcStatusResponse{
+				peerID: src.ID(),
+				base:   msg.StatusResponse.Base,
+				height: msg.StatusResponse.Height,
+			}
 		}
 		r.mtx.RUnlock()
 
-	case *bcproto.BlockResponse:
-		bi, err := types.BlockFromProto(msg.Block)
+	case *bcproto.Message_BlockResponse:
+		bi, err := types.BlockFromProto(msg.BlockResponse.Block)
 		if err != nil {
-			r.logger.Error("error transitioning block from protobuf", "err", err)
+			logger.Error("error transitioning block from protobuf", "err", err)
+			_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
 			return
 		}
 		r.mtx.RLock()
@@ -516,10 +532,14 @@ func (r *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 		}
 		r.mtx.RUnlock()
 
-	case *bcproto.NoBlockResponse:
+	case *bcproto.Message_NoBlockResponse:
 		r.mtx.RLock()
 		if r.events != nil {
-			r.events <- bcNoBlockResponse{peerID: src.ID(), height: msg.Height, time: time.Now()}
+			r.events <- bcNoBlockResponse{
+				peerID: src.ID(),
+				height: msg.NoBlockResponse.Height,
+				time:   time.Now(),
+			}
 		}
 		r.mtx.RUnlock()
 	}
@@ -527,10 +547,16 @@ func (r *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
 
 // AddPeer implements Reactor interface
 func (r *BlockchainReactor) AddPeer(peer p2p.Peer) {
-	err := r.io.sendStatusResponse(r.store.Base(), r.store.Height(), peer.ID())
+	err := r.io.sendStatusResponse(r.store.Base(), r.store.Height(), peer)
 	if err != nil {
-		r.logger.Error("Could not send status message to peer new", "src", peer.ID, "height", r.SyncHeight())
+		r.logger.Error("could not send our status to the new peer", "peer", peer.ID, "err", err)
 	}
+
+	err = r.io.sendStatusRequest(peer)
+	if err != nil {
+		r.logger.Error("could not send status request to the new peer", "peer", peer.ID, "err", err)
+	}
+
 	r.mtx.RLock()
 	defer r.mtx.RUnlock()
 	if r.events != nil {

blockchain/v2/reactor_test.go

@@ -4,19 +4,19 @@ import (
 	"fmt"
 	"net"
 	"os"
-	"sort"
 	"sync"
 	"testing"
 	"time"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	dbm "github.com/tendermint/tm-db"
 
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/behaviour"
-	bc "github.com/tendermint/tendermint/blockchain"
+	"github.com/tendermint/tendermint/blockchain/v2/internal/behavior"
 	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 	"github.com/tendermint/tendermint/mempool/mock"
@@ -27,16 +27,15 @@ import (
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
-	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
 type mockPeer struct {
 	service.Service
-	id p2p.ID
+	id p2p.NodeID
 }
 
 func (mp mockPeer) FlushStop()           {}
-func (mp mockPeer) ID() p2p.ID           { return mp.id }
+func (mp mockPeer) ID() p2p.NodeID       { return mp.id }
 func (mp mockPeer) RemoteIP() net.IP     { return net.IP{} }
 func (mp mockPeer) RemoteAddr() net.Addr { return &net.TCPAddr{IP: mp.RemoteIP(), Port: 8800} }
 
@@ -45,9 +44,9 @@ func (mp mockPeer) IsPersistent() bool { return true }
 func (mp mockPeer) CloseConn() error   { return nil }
 
 func (mp mockPeer) NodeInfo() p2p.NodeInfo {
-	return p2p.DefaultNodeInfo{
-		DefaultNodeID: "",
-		ListenAddr:    "",
+	return p2p.NodeInfo{
+		NodeID:     "",
+		ListenAddr: "",
 	}
 }
 func (mp mockPeer) Status() conn.ConnectionStatus { return conn.ConnectionStatus{} }
@@ -59,22 +58,22 @@ func (mp mockPeer) TrySend(byte, []byte) bool { return true }
 func (mp mockPeer) Set(string, interface{}) {}
 func (mp mockPeer) Get(string) interface{}  { return struct{}{} }
 
-// nolint:unused // ignore
+//nolint:unused
 type mockBlockStore struct {
 	blocks map[int64]*types.Block
 }
 
-// nolint:unused // ignore
+//nolint:unused
 func (ml *mockBlockStore) Height() int64 {
 	return int64(len(ml.blocks))
 }
 
-// nolint:unused // ignore
+//nolint:unused
 func (ml *mockBlockStore) LoadBlock(height int64) *types.Block {
 	return ml.blocks[height]
 }
 
-// nolint:unused // ignore
+//nolint:unused
 func (ml *mockBlockStore) SaveBlock(block *types.Block, part *types.PartSet, commit *types.Commit) {
 	ml.blocks[block.Height] = block
 }
@@ -96,34 +95,37 @@ type mockSwitchIo struct {
 	numStatusResponse   int
 	numBlockResponse    int
 	numNoBlockResponse  int
+	numStatusRequest    int
 }
 
-func (sio *mockSwitchIo) sendBlockRequest(peerID p2p.ID, height int64) error {
+var _ iIO = (*mockSwitchIo)(nil)
+
+func (sio *mockSwitchIo) sendBlockRequest(_ p2p.Peer, _ int64) error {
 	return nil
 }
 
-func (sio *mockSwitchIo) sendStatusResponse(base, height int64, peerID p2p.ID) error {
+func (sio *mockSwitchIo) sendStatusResponse(_, _ int64, _ p2p.Peer) error {
 	sio.mtx.Lock()
 	defer sio.mtx.Unlock()
 	sio.numStatusResponse++
 	return nil
 }
 
-func (sio *mockSwitchIo) sendBlockToPeer(block *types.Block, peerID p2p.ID) error {
+func (sio *mockSwitchIo) sendBlockToPeer(_ *types.Block, _ p2p.Peer) error {
 	sio.mtx.Lock()
 	defer sio.mtx.Unlock()
 	sio.numBlockResponse++
 	return nil
 }
 
-func (sio *mockSwitchIo) sendBlockNotFound(height int64, peerID p2p.ID) error {
+func (sio *mockSwitchIo) sendBlockNotFound(_ int64, _ p2p.Peer) error {
 	sio.mtx.Lock()
 	defer sio.mtx.Unlock()
 	sio.numNoBlockResponse++
 	return nil
 }
 
-func (sio *mockSwitchIo) trySwitchToConsensus(state sm.State, skipWAL bool) bool {
+func (sio *mockSwitchIo) trySwitchToConsensus(_ sm.State, _ bool) bool {
 	sio.mtx.Lock()
 	defer sio.mtx.Unlock()
 	sio.switchedToConsensus = true
@@ -134,6 +136,13 @@ func (sio *mockSwitchIo) broadcastStatusRequest() error {
 	return nil
 }
 
+func (sio *mockSwitchIo) sendStatusRequest(_ p2p.Peer) error {
+	sio.mtx.Lock()
+	defer sio.mtx.Unlock()
+	sio.numStatusRequest++
+	return nil
+}
+
 type testReactorParams struct {
 	logger      log.Logger
 	genDoc      *types.GenesisDoc
@@ -144,7 +153,7 @@ type testReactorParams struct {
 
 func newTestReactor(p testReactorParams) *BlockchainReactor {
 	store, state, _ := newReactorStore(p.genDoc, p.privVals, p.startHeight)
-	reporter := behaviour.NewMockReporter()
+	reporter := behavior.NewMockReporter()
 
 	var appl blockApplier
 
@@ -301,7 +310,7 @@ func newTestReactor(p testReactorParams) *BlockchainReactor {
 // 		t.Run(tt.name, func(t *testing.T) {
 // 			reactor := newTestReactor(params)
 // 			reactor.Start()
-// 			reactor.reporter = behaviour.NewMockReporter()
+// 			reactor.reporter = behavior.NewMockReporter()
 // 			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
 // 			reactor.io = mockSwitch
 // 			// time for go routines to start
@@ -356,7 +365,7 @@ func TestReactorHelperMode(t *testing.T) {
 
 	config := cfg.ResetTestRoot("blockchain_reactor_v2_test")
 	defer os.RemoveAll(config.RootDir)
-	genDoc, privVals := randGenesisDoc(config.ChainID(), 1, false, 30)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
 
 	params := testReactorParams{
 		logger:      log.TestingLogger(),
@@ -402,23 +411,37 @@ func TestReactorHelperMode(t *testing.T) {
 				switch ev := step.event.(type) {
 				case bcproto.StatusRequest:
 					old := mockSwitch.numStatusResponse
-					msg, err := bc.EncodeMsg(&ev)
-					assert.NoError(t, err)
-					reactor.Receive(channelID, mockPeer{id: p2p.ID(step.peer)}, msg)
+
+					msgProto := new(bcproto.Message)
+					require.NoError(t, msgProto.Wrap(&ev))
+
+					msgBz, err := proto.Marshal(msgProto)
+					require.NoError(t, err)
+
+					reactor.Receive(channelID, mockPeer{id: p2p.NodeID(step.peer)}, msgBz)
 					assert.Equal(t, old+1, mockSwitch.numStatusResponse)
 				case bcproto.BlockRequest:
 					if ev.Height > params.startHeight {
 						old := mockSwitch.numNoBlockResponse
-						msg, err := bc.EncodeMsg(&ev)
-						assert.NoError(t, err)
-						reactor.Receive(channelID, mockPeer{id: p2p.ID(step.peer)}, msg)
+
+						msgProto := new(bcproto.Message)
+						require.NoError(t, msgProto.Wrap(&ev))
+
+						msgBz, err := proto.Marshal(msgProto)
+						require.NoError(t, err)
+
+						reactor.Receive(channelID, mockPeer{id: p2p.NodeID(step.peer)}, msgBz)
 						assert.Equal(t, old+1, mockSwitch.numNoBlockResponse)
 					} else {
 						old := mockSwitch.numBlockResponse
-						msg, err := bc.EncodeMsg(&ev)
-						assert.NoError(t, err)
-						assert.NoError(t, err)
-						reactor.Receive(channelID, mockPeer{id: p2p.ID(step.peer)}, msg)
+
+						msgProto := new(bcproto.Message)
+						require.NoError(t, msgProto.Wrap(&ev))
+
+						msgBz, err := proto.Marshal(msgProto)
+						require.NoError(t, err)
+
+						reactor.Receive(channelID, mockPeer{id: p2p.NodeID(step.peer)}, msgBz)
 						assert.Equal(t, old+1, mockSwitch.numBlockResponse)
 					}
 				}
@@ -432,7 +455,7 @@ func TestReactorHelperMode(t *testing.T) {
 func TestReactorSetSwitchNil(t *testing.T) {
 	config := cfg.ResetTestRoot("blockchain_reactor_v2_test")
 	defer os.RemoveAll(config.RootDir)
-	genDoc, privVals := randGenesisDoc(config.ChainID(), 1, false, 30)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
 
 	reactor := newTestReactor(testReactorParams{
 		logger:   log.TestingLogger(),
@@ -464,27 +487,6 @@ type testApp struct {
 	abci.BaseApplication
 }
 
-func randGenesisDoc(chainID string, numValidators int, randPower bool, minPower int64) (
-	*types.GenesisDoc, []types.PrivValidator) {
-	validators := make([]types.GenesisValidator, numValidators)
-	privValidators := make([]types.PrivValidator, numValidators)
-	for i := 0; i < numValidators; i++ {
-		val, privVal := types.RandValidator(randPower, minPower)
-		validators[i] = types.GenesisValidator{
-			PubKey: val.PubKey,
-			Power:  val.VotingPower,
-		}
-		privValidators[i] = privVal
-	}
-	sort.Sort(types.PrivValidatorsByAddress(privValidators))
-
-	return &types.GenesisDoc{
-		GenesisTime: tmtime.Now(),
-		ChainID:     chainID,
-		Validators:  validators,
-	}, privValidators
-}
-
 // Why are we importing the entire blockExecutor dependency graph here
 // when we have the facilities to
 func newReactorStore(
@@ -524,12 +526,11 @@ func newReactorStore(
 		if blockHeight > 1 {
 			lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
 			lastBlock := blockStore.LoadBlock(blockHeight - 1)
-			vote, err := types.MakeVote(
-				lastBlock.Header.Height,
-				lastBlockMeta.BlockID,
-				state.Validators,
+			vote, err := factory.MakeVote(
 				privVals[0],
-				lastBlock.Header.ChainID,
+				lastBlock.Header.ChainID, 0,
+				lastBlock.Header.Height, 0, 2,
+				lastBlockMeta.BlockID,
 				time.Now(),
 			)
 			if err != nil {

blockchain/v2/routine.go

@@ -58,7 +58,7 @@ func (rt *Routine) setMetrics(metrics *Metrics) {
 }
 
 func (rt *Routine) start() {
-	rt.logger.Info("routine start", "msg", log.NewLazySprintf("%s: run", rt.name))
+	rt.logger.Info(fmt.Sprintf("%s: run", rt.name))
 	running := atomic.CompareAndSwapUint32(rt.running, uint32(0), uint32(1))
 	if !running {
 		panic(fmt.Sprintf("%s is already running", rt.name))
@@ -98,7 +98,7 @@ func (rt *Routine) start() {
 			return
 		}
 		rt.metrics.EventsOut.With("routine", rt.name).Add(1)
-		rt.logger.Debug("routine start", "msg", log.NewLazySprintf("%s: produced %T %+v", rt.name, oEvent, oEvent))
+		rt.logger.Debug(fmt.Sprintf("%s: produced %T %+v", rt.name, oEvent, oEvent))
 
 		// Skip rTrySchedule and rProcessBlock events as they clutter the history
 		// due to their frequency.
@@ -118,7 +118,7 @@ func (rt *Routine) start() {
 
 // XXX: look into returning OpError in the net package
 func (rt *Routine) send(event Event) bool {
-	rt.logger.Debug("routine send", "msg", log.NewLazySprintf("%s: received %T %+v", rt.name, event, event))
+	rt.logger.Debug(fmt.Sprintf("%s: received %T %+v", rt.name, event, event))
 	if !rt.isRunning() {
 		return false
 	}
@@ -150,7 +150,7 @@ func (rt *Routine) stop() {
 		return
 	}
 
-	rt.logger.Info("routine stop", "msg", log.NewLazySprintf("%s: stop", rt.name))
+	rt.logger.Info(fmt.Sprintf("%s: stop", rt.name))
 	rt.queue.Dispose() // this should block until all queue items are free?
 }
 

blockchain/v2/scheduler.go

@@ -26,7 +26,7 @@ func (e scFinishedEv) String() string {
 // send a blockRequest message
 type scBlockRequest struct {
 	priorityNormal
-	peerID p2p.ID
+	peerID p2p.NodeID
 	height int64
 }
 
@@ -37,7 +37,7 @@ func (e scBlockRequest) String() string {
 // a block has been received and validated by the scheduler
 type scBlockReceived struct {
 	priorityNormal
-	peerID p2p.ID
+	peerID p2p.NodeID
 	block  *types.Block
 }
 
@@ -48,7 +48,7 @@ func (e scBlockReceived) String() string {
 // scheduler detected a peer error
 type scPeerError struct {
 	priorityHigh
-	peerID p2p.ID
+	peerID p2p.NodeID
 	reason error
 }
 
@@ -59,7 +59,7 @@ func (e scPeerError) String() string {
 // scheduler removed a set of peers (timed out or slow peer)
 type scPeersPruned struct {
 	priorityHigh
-	peers []p2p.ID
+	peers []p2p.NodeID
 }
 
 func (e scPeersPruned) String() string {
@@ -126,7 +126,7 @@ func (e peerState) String() string {
 }
 
 type scPeer struct {
-	peerID p2p.ID
+	peerID p2p.NodeID
 
 	// initialized as New when peer is added, updated to Ready when statusUpdate is received,
 	// updated to Removed when peer is removed
@@ -143,7 +143,7 @@ func (p scPeer) String() string {
 		p.state, p.base, p.height, p.lastTouched, p.lastRate, p.peerID)
 }
 
-func newScPeer(peerID p2p.ID) *scPeer {
+func newScPeer(peerID p2p.NodeID) *scPeer {
 	return &scPeer{
 		peerID:      peerID,
 		state:       peerStateNew,
@@ -171,7 +171,7 @@ type scheduler struct {
 
 	// a map of peerID to scheduler specific peer struct `scPeer` used to keep
 	// track of peer specific state
-	peers       map[p2p.ID]*scPeer
+	peers       map[p2p.NodeID]*scPeer
 	peerTimeout time.Duration // maximum response time from a peer otherwise prune
 	minRecvRate int64         // minimum receive rate from peer otherwise prune
 
@@ -183,13 +183,13 @@ type scheduler struct {
 	blockStates map[int64]blockState
 
 	// a map of heights to the peer we are waiting a response from
-	pendingBlocks map[int64]p2p.ID
+	pendingBlocks map[int64]p2p.NodeID
 
 	// the time at which a block was put in blockStatePending
 	pendingTime map[int64]time.Time
 
 	// a map of heights to the peers that put the block in blockStateReceived
-	receivedBlocks map[int64]p2p.ID
+	receivedBlocks map[int64]p2p.NodeID
 }
 
 func (sc scheduler) String() string {
@@ -204,10 +204,10 @@ func newScheduler(initHeight int64, startTime time.Time) *scheduler {
 		syncTimeout:    60 * time.Second,
 		height:         initHeight,
 		blockStates:    make(map[int64]blockState),
-		peers:          make(map[p2p.ID]*scPeer),
-		pendingBlocks:  make(map[int64]p2p.ID),
+		peers:          make(map[p2p.NodeID]*scPeer),
+		pendingBlocks:  make(map[int64]p2p.NodeID),
 		pendingTime:    make(map[int64]time.Time),
-		receivedBlocks: make(map[int64]p2p.ID),
+		receivedBlocks: make(map[int64]p2p.NodeID),
 		targetPending:  10,               // TODO - pass as param
 		peerTimeout:    15 * time.Second, // TODO - pass as param
 		minRecvRate:    0,                // int64(7680), TODO - pass as param
@@ -216,14 +216,14 @@ func newScheduler(initHeight int64, startTime time.Time) *scheduler {
 	return &sc
 }
 
-func (sc *scheduler) ensurePeer(peerID p2p.ID) *scPeer {
+func (sc *scheduler) ensurePeer(peerID p2p.NodeID) *scPeer {
 	if _, ok := sc.peers[peerID]; !ok {
 		sc.peers[peerID] = newScPeer(peerID)
 	}
 	return sc.peers[peerID]
 }
 
-func (sc *scheduler) touchPeer(peerID p2p.ID, time time.Time) error {
+func (sc *scheduler) touchPeer(peerID p2p.NodeID, time time.Time) error {
 	peer, ok := sc.peers[peerID]
 	if !ok {
 		return fmt.Errorf("couldn't find peer %s", peerID)
@@ -238,7 +238,7 @@ func (sc *scheduler) touchPeer(peerID p2p.ID, time time.Time) error {
 	return nil
 }
 
-func (sc *scheduler) removePeer(peerID p2p.ID) {
+func (sc *scheduler) removePeer(peerID p2p.NodeID) {
 	peer, ok := sc.peers[peerID]
 	if !ok {
 		return
@@ -298,7 +298,7 @@ func (sc *scheduler) addNewBlocks() {
 	}
 }
 
-func (sc *scheduler) setPeerRange(peerID p2p.ID, base int64, height int64) error {
+func (sc *scheduler) setPeerRange(peerID p2p.NodeID, base int64, height int64) error {
 	peer := sc.ensurePeer(peerID)
 
 	if peer.state == peerStateRemoved {
@@ -333,8 +333,8 @@ func (sc *scheduler) getStateAtHeight(height int64) blockState {
 	}
 }
 
-func (sc *scheduler) getPeersWithHeight(height int64) []p2p.ID {
-	peers := make([]p2p.ID, 0)
+func (sc *scheduler) getPeersWithHeight(height int64) []p2p.NodeID {
+	peers := make([]p2p.NodeID, 0)
 	for _, peer := range sc.peers {
 		if peer.state != peerStateReady {
 			continue
@@ -346,8 +346,8 @@ func (sc *scheduler) getPeersWithHeight(height int64) []p2p.ID {
 	return peers
 }
 
-func (sc *scheduler) prunablePeers(peerTimout time.Duration, minRecvRate int64, now time.Time) []p2p.ID {
-	prunable := make([]p2p.ID, 0)
+func (sc *scheduler) prunablePeers(peerTimout time.Duration, minRecvRate int64, now time.Time) []p2p.NodeID {
+	prunable := make([]p2p.NodeID, 0)
 	for peerID, peer := range sc.peers {
 		if peer.state != peerStateReady {
 			continue
@@ -366,7 +366,7 @@ func (sc *scheduler) setStateAtHeight(height int64, state blockState) {
 }
 
 // CONTRACT: peer exists and in Ready state.
-func (sc *scheduler) markReceived(peerID p2p.ID, height int64, size int64, now time.Time) error {
+func (sc *scheduler) markReceived(peerID p2p.NodeID, height int64, size int64, now time.Time) error {
 	peer := sc.peers[peerID]
 
 	if state := sc.getStateAtHeight(height); state != blockStatePending || sc.pendingBlocks[height] != peerID {
@@ -390,7 +390,7 @@ func (sc *scheduler) markReceived(peerID p2p.ID, height int64, size int64, now t
 	return nil
 }
 
-func (sc *scheduler) markPending(peerID p2p.ID, height int64, time time.Time) error {
+func (sc *scheduler) markPending(peerID p2p.NodeID, height int64, time time.Time) error {
 	state := sc.getStateAtHeight(height)
 	if state != blockStateNew {
 		return fmt.Errorf("block %d should be in blockStateNew but is %s", height, state)
@@ -472,7 +472,7 @@ func (sc *scheduler) nextHeightToSchedule() int64 {
 	return min
 }
 
-func (sc *scheduler) pendingFrom(peerID p2p.ID) []int64 {
+func (sc *scheduler) pendingFrom(peerID p2p.NodeID) []int64 {
 	var heights []int64
 	for height, pendingPeerID := range sc.pendingBlocks {
 		if pendingPeerID == peerID {
@@ -482,7 +482,7 @@ func (sc *scheduler) pendingFrom(peerID p2p.ID) []int64 {
 	return heights
 }
 
-func (sc *scheduler) selectPeer(height int64) (p2p.ID, error) {
+func (sc *scheduler) selectPeer(height int64) (p2p.NodeID, error) {
 	peers := sc.getPeersWithHeight(height)
 	if len(peers) == 0 {
 		return "", fmt.Errorf("cannot find peer for height %d", height)
@@ -490,7 +490,7 @@ func (sc *scheduler) selectPeer(height int64) (p2p.ID, error) {
 
 	// create a map from number of pending requests to a list
 	// of peers having that number of pending requests.
-	pendingFrom := make(map[int][]p2p.ID)
+	pendingFrom := make(map[int][]p2p.NodeID)
 	for _, peerID := range peers {
 		numPending := len(sc.pendingFrom(peerID))
 		pendingFrom[numPending] = append(pendingFrom[numPending], peerID)
@@ -509,7 +509,7 @@ func (sc *scheduler) selectPeer(height int64) (p2p.ID, error) {
 }
 
 // PeerByID is a list of peers sorted by peerID.
-type PeerByID []p2p.ID
+type PeerByID []p2p.NodeID
 
 func (peers PeerByID) Len() int {
 	return len(peers)

blockchain/v2/scheduler_test.go

@@ -20,9 +20,9 @@ type scTestParams struct {
 	initHeight    int64
 	height        int64
 	allB          []int64
-	pending       map[int64]p2p.ID
+	pending       map[int64]p2p.NodeID
 	pendingTime   map[int64]time.Time
-	received      map[int64]p2p.ID
+	received      map[int64]p2p.NodeID
 	peerTimeout   time.Duration
 	minRecvRate   int64
 	targetPending int
@@ -41,7 +41,7 @@ func verifyScheduler(sc *scheduler) {
 }
 
 func newTestScheduler(params scTestParams) *scheduler {
-	peers := make(map[p2p.ID]*scPeer)
+	peers := make(map[p2p.NodeID]*scPeer)
 	var maxHeight int64
 
 	initHeight := params.initHeight
@@ -54,8 +54,8 @@ func newTestScheduler(params scTestParams) *scheduler {
 	}
 
 	for id, peer := range params.peers {
-		peer.peerID = p2p.ID(id)
-		peers[p2p.ID(id)] = peer
+		peer.peerID = p2p.NodeID(id)
+		peers[p2p.NodeID(id)] = peer
 		if maxHeight < peer.height {
 			maxHeight = peer.height
 		}
@@ -122,7 +122,7 @@ func TestScMaxHeights(t *testing.T) {
 			name: "one ready peer",
 			sc: scheduler{
 				height: 3,
-				peers:  map[p2p.ID]*scPeer{"P1": {height: 6, state: peerStateReady}},
+				peers:  map[p2p.NodeID]*scPeer{"P1": {height: 6, state: peerStateReady}},
 			},
 			wantMax: 6,
 		},
@@ -130,7 +130,7 @@ func TestScMaxHeights(t *testing.T) {
 			name: "ready and removed peers",
 			sc: scheduler{
 				height: 1,
-				peers: map[p2p.ID]*scPeer{
+				peers: map[p2p.NodeID]*scPeer{
 					"P1": {height: 4, state: peerStateReady},
 					"P2": {height: 10, state: peerStateRemoved}},
 			},
@@ -140,7 +140,7 @@ func TestScMaxHeights(t *testing.T) {
 			name: "removed peers",
 			sc: scheduler{
 				height: 1,
-				peers: map[p2p.ID]*scPeer{
+				peers: map[p2p.NodeID]*scPeer{
 					"P1": {height: 4, state: peerStateRemoved},
 					"P2": {height: 10, state: peerStateRemoved}},
 			},
@@ -150,7 +150,7 @@ func TestScMaxHeights(t *testing.T) {
 			name: "new peers",
 			sc: scheduler{
 				height: 1,
-				peers: map[p2p.ID]*scPeer{
+				peers: map[p2p.NodeID]*scPeer{
 					"P1": {base: -1, height: -1, state: peerStateNew},
 					"P2": {base: -1, height: -1, state: peerStateNew}},
 			},
@@ -160,7 +160,7 @@ func TestScMaxHeights(t *testing.T) {
 			name: "mixed peers",
 			sc: scheduler{
 				height: 1,
-				peers: map[p2p.ID]*scPeer{
+				peers: map[p2p.NodeID]*scPeer{
 					"P1": {height: -1, state: peerStateNew},
 					"P2": {height: 10, state: peerStateReady},
 					"P3": {height: 20, state: peerStateRemoved},
@@ -187,7 +187,7 @@ func TestScMaxHeights(t *testing.T) {
 func TestScEnsurePeer(t *testing.T) {
 
 	type args struct {
-		peerID p2p.ID
+		peerID p2p.NodeID
 	}
 	tests := []struct {
 		name       string
@@ -244,7 +244,7 @@ func TestScTouchPeer(t *testing.T) {
 	now := time.Now()
 
 	type args struct {
-		peerID p2p.ID
+		peerID p2p.NodeID
 		time   time.Time
 	}
 
@@ -316,13 +316,13 @@ func TestScPrunablePeers(t *testing.T) {
 		name       string
 		fields     scTestParams
 		args       args
-		wantResult []p2p.ID
+		wantResult []p2p.NodeID
 	}{
 		{
 			name:       "no peers",
 			fields:     scTestParams{peers: map[string]*scPeer{}},
 			args:       args{threshold: time.Second, time: now.Add(time.Second + time.Millisecond), minSpeed: 100},
-			wantResult: []p2p.ID{},
+			wantResult: []p2p.NodeID{},
 		},
 		{
 			name: "mixed peers",
@@ -341,7 +341,7 @@ func TestScPrunablePeers(t *testing.T) {
 				"P6": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 90},
 			}},
 			args:       args{threshold: time.Second, time: now.Add(time.Second + time.Millisecond), minSpeed: 100},
-			wantResult: []p2p.ID{"P4", "P5", "P6"},
+			wantResult: []p2p.NodeID{"P4", "P5", "P6"},
 		},
 	}
 
@@ -361,7 +361,7 @@ func TestScPrunablePeers(t *testing.T) {
 func TestScRemovePeer(t *testing.T) {
 
 	type args struct {
-		peerID p2p.ID
+		peerID p2p.NodeID
 	}
 	tests := []struct {
 		name       string
@@ -424,13 +424,13 @@ func TestScRemovePeer(t *testing.T) {
 			fields: scTestParams{
 				peers:   map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
 				allB:    []int64{1, 2, 3},
-				pending: map[int64]p2p.ID{1: "P1"},
+				pending: map[int64]p2p.NodeID{1: "P1"},
 			},
 			args: args{peerID: "P1"},
 			wantFields: scTestParams{
 				peers:   map[string]*scPeer{"P1": {height: 3, state: peerStateRemoved}},
 				allB:    []int64{},
-				pending: map[int64]p2p.ID{},
+				pending: map[int64]p2p.NodeID{},
 			},
 		},
 		{
@@ -438,13 +438,13 @@ func TestScRemovePeer(t *testing.T) {
 			fields: scTestParams{
 				peers:    map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
 				allB:     []int64{1, 2, 3},
-				received: map[int64]p2p.ID{1: "P1"},
+				received: map[int64]p2p.NodeID{1: "P1"},
 			},
 			args: args{peerID: "P1"},
 			wantFields: scTestParams{
 				peers:    map[string]*scPeer{"P1": {height: 3, state: peerStateRemoved}},
 				allB:     []int64{},
-				received: map[int64]p2p.ID{},
+				received: map[int64]p2p.NodeID{},
 			},
 		},
 		{
@@ -452,15 +452,15 @@ func TestScRemovePeer(t *testing.T) {
 			fields: scTestParams{
 				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:     []int64{1, 2, 3, 4},
-				pending:  map[int64]p2p.ID{1: "P1", 3: "P1"},
-				received: map[int64]p2p.ID{2: "P1", 4: "P1"},
+				pending:  map[int64]p2p.NodeID{1: "P1", 3: "P1"},
+				received: map[int64]p2p.NodeID{2: "P1", 4: "P1"},
 			},
 			args: args{peerID: "P1"},
 			wantFields: scTestParams{
 				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}},
 				allB:     []int64{},
-				pending:  map[int64]p2p.ID{},
-				received: map[int64]p2p.ID{},
+				pending:  map[int64]p2p.NodeID{},
+				received: map[int64]p2p.NodeID{},
 			},
 		},
 		{
@@ -471,8 +471,8 @@ func TestScRemovePeer(t *testing.T) {
 					"P2": {height: 6, state: peerStateReady},
 				},
 				allB:     []int64{1, 2, 3, 4, 5, 6},
-				pending:  map[int64]p2p.ID{1: "P1", 3: "P2", 6: "P1"},
-				received: map[int64]p2p.ID{2: "P1", 4: "P2", 5: "P2"},
+				pending:  map[int64]p2p.NodeID{1: "P1", 3: "P2", 6: "P1"},
+				received: map[int64]p2p.NodeID{2: "P1", 4: "P2", 5: "P2"},
 			},
 			args: args{peerID: "P1"},
 			wantFields: scTestParams{
@@ -481,8 +481,8 @@ func TestScRemovePeer(t *testing.T) {
 					"P2": {height: 6, state: peerStateReady},
 				},
 				allB:     []int64{1, 2, 3, 4, 5, 6},
-				pending:  map[int64]p2p.ID{3: "P2"},
-				received: map[int64]p2p.ID{4: "P2", 5: "P2"},
+				pending:  map[int64]p2p.NodeID{3: "P2"},
+				received: map[int64]p2p.NodeID{4: "P2", 5: "P2"},
 			},
 		},
 	}
@@ -501,7 +501,7 @@ func TestScRemovePeer(t *testing.T) {
 func TestScSetPeerRange(t *testing.T) {
 
 	type args struct {
-		peerID p2p.ID
+		peerID p2p.NodeID
 		base   int64
 		height int64
 	}
@@ -622,25 +622,25 @@ func TestScGetPeersWithHeight(t *testing.T) {
 		name       string
 		fields     scTestParams
 		args       args
-		wantResult []p2p.ID
+		wantResult []p2p.NodeID
 	}{
 		{
 			name:       "no peers",
 			fields:     scTestParams{peers: map[string]*scPeer{}},
 			args:       args{height: 10},
-			wantResult: []p2p.ID{},
+			wantResult: []p2p.NodeID{},
 		},
 		{
 			name:       "only new peers",
 			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateNew}}},
 			args:       args{height: 10},
-			wantResult: []p2p.ID{},
+			wantResult: []p2p.NodeID{},
 		},
 		{
 			name:       "only Removed peers",
 			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
 			args:       args{height: 2},
-			wantResult: []p2p.ID{},
+			wantResult: []p2p.NodeID{},
 		},
 		{
 			name: "one Ready shorter peer",
@@ -649,7 +649,7 @@ func TestScGetPeersWithHeight(t *testing.T) {
 				allB:  []int64{1, 2, 3, 4},
 			},
 			args:       args{height: 5},
-			wantResult: []p2p.ID{},
+			wantResult: []p2p.NodeID{},
 		},
 		{
 			name: "one Ready equal peer",
@@ -658,7 +658,7 @@ func TestScGetPeersWithHeight(t *testing.T) {
 				allB:  []int64{1, 2, 3, 4},
 			},
 			args:       args{height: 4},
-			wantResult: []p2p.ID{"P1"},
+			wantResult: []p2p.NodeID{"P1"},
 		},
 		{
 			name: "one Ready higher peer",
@@ -668,7 +668,7 @@ func TestScGetPeersWithHeight(t *testing.T) {
 				allB:          []int64{1, 2, 3, 4},
 			},
 			args:       args{height: 4},
-			wantResult: []p2p.ID{"P1"},
+			wantResult: []p2p.NodeID{"P1"},
 		},
 		{
 			name: "one Ready higher peer at base",
@@ -678,7 +678,7 @@ func TestScGetPeersWithHeight(t *testing.T) {
 				allB:          []int64{1, 2, 3, 4},
 			},
 			args:       args{height: 4},
-			wantResult: []p2p.ID{"P1"},
+			wantResult: []p2p.NodeID{"P1"},
 		},
 		{
 			name: "one Ready higher peer with higher base",
@@ -688,7 +688,7 @@ func TestScGetPeersWithHeight(t *testing.T) {
 				allB:          []int64{1, 2, 3, 4},
 			},
 			args:       args{height: 4},
-			wantResult: []p2p.ID{},
+			wantResult: []p2p.NodeID{},
 		},
 		{
 			name: "multiple mixed peers",
@@ -703,7 +703,7 @@ func TestScGetPeersWithHeight(t *testing.T) {
 				allB: []int64{8, 9, 10, 11},
 			},
 			args:       args{height: 8},
-			wantResult: []p2p.ID{"P2", "P5"},
+			wantResult: []p2p.NodeID{"P2", "P5"},
 		},
 	}
 
@@ -725,7 +725,7 @@ func TestScMarkPending(t *testing.T) {
 	now := time.Now()
 
 	type args struct {
-		peerID p2p.ID
+		peerID p2p.NodeID
 		height int64
 		tm     time.Time
 	}
@@ -821,14 +821,14 @@ func TestScMarkPending(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{1, 2},
-				pending:     map[int64]p2p.ID{1: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1"},
 				pendingTime: map[int64]time.Time{1: now},
 			},
 			args: args{peerID: "P1", height: 2, tm: now.Add(time.Millisecond)},
 			wantFields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{1, 2},
-				pending:     map[int64]p2p.ID{1: "P1", 2: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
 				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Millisecond)},
 			},
 		},
@@ -851,7 +851,7 @@ func TestScMarkReceived(t *testing.T) {
 	now := time.Now()
 
 	type args struct {
-		peerID p2p.ID
+		peerID p2p.NodeID
 		height int64
 		size   int64
 		tm     time.Time
@@ -891,7 +891,7 @@ func TestScMarkReceived(t *testing.T) {
 					"P2": {height: 4, state: peerStateReady},
 				},
 				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]p2p.ID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
+				pending: map[int64]p2p.NodeID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
 			},
 			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
 			wantFields: scTestParams{
@@ -900,7 +900,7 @@ func TestScMarkReceived(t *testing.T) {
 					"P2": {height: 4, state: peerStateReady},
 				},
 				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]p2p.ID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
+				pending: map[int64]p2p.NodeID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
 			},
 			wantErr: true,
 		},
@@ -909,13 +909,13 @@ func TestScMarkReceived(t *testing.T) {
 			fields: scTestParams{
 				peers:   map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]p2p.ID{},
+				pending: map[int64]p2p.NodeID{},
 			},
 			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
 			wantFields: scTestParams{
 				peers:   map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]p2p.ID{},
+				pending: map[int64]p2p.NodeID{},
 			},
 			wantErr: true,
 		},
@@ -924,14 +924,14 @@ func TestScMarkReceived(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{1, 2},
-				pending:     map[int64]p2p.ID{1: "P1", 2: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
 				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Second)},
 			},
 			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
 			wantFields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{1, 2},
-				pending:     map[int64]p2p.ID{1: "P1", 2: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
 				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Second)},
 			},
 			wantErr: true,
@@ -941,16 +941,16 @@ func TestScMarkReceived(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{1, 2},
-				pending:     map[int64]p2p.ID{1: "P1", 2: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
 				pendingTime: map[int64]time.Time{1: now, 2: now},
 			},
 			args: args{peerID: "P1", height: 2, size: 1000, tm: now.Add(time.Millisecond)},
 			wantFields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{1, 2},
-				pending:     map[int64]p2p.ID{1: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1"},
 				pendingTime: map[int64]time.Time{1: now},
-				received:    map[int64]p2p.ID{2: "P1"},
+				received:    map[int64]p2p.NodeID{2: "P1"},
 			},
 		},
 	}
@@ -991,7 +991,7 @@ func TestScMarkProcessed(t *testing.T) {
 				height:        2,
 				peers:         map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:          []int64{2},
-				pending:       map[int64]p2p.ID{2: "P1"},
+				pending:       map[int64]p2p.NodeID{2: "P1"},
 				pendingTime:   map[int64]time.Time{2: now},
 				targetPending: 1,
 			},
@@ -1009,15 +1009,15 @@ func TestScMarkProcessed(t *testing.T) {
 				height:      1,
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{1, 2},
-				pending:     map[int64]p2p.ID{2: "P1"},
+				pending:     map[int64]p2p.NodeID{2: "P1"},
 				pendingTime: map[int64]time.Time{2: now},
-				received:    map[int64]p2p.ID{1: "P1"}},
+				received:    map[int64]p2p.NodeID{1: "P1"}},
 			args: args{height: 1},
 			wantFields: scTestParams{
 				height:      2,
 				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
 				allB:        []int64{2},
-				pending:     map[int64]p2p.ID{2: "P1"},
+				pending:     map[int64]p2p.NodeID{2: "P1"},
 				pendingTime: map[int64]time.Time{2: now}},
 		},
 	}
@@ -1101,7 +1101,7 @@ func TestScAllBlocksProcessed(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]p2p.ID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
 				pendingTime: map[int64]time.Time{1: now, 2: now, 3: now, 4: now},
 			},
 			wantResult: false,
@@ -1111,7 +1111,7 @@ func TestScAllBlocksProcessed(t *testing.T) {
 			fields: scTestParams{
 				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:     []int64{1, 2, 3, 4},
-				received: map[int64]p2p.ID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
+				received: map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
 			},
 			wantResult: false,
 		},
@@ -1122,7 +1122,7 @@ func TestScAllBlocksProcessed(t *testing.T) {
 				peers: map[string]*scPeer{
 					"P1": {height: 4, state: peerStateReady}},
 				allB:     []int64{4},
-				received: map[int64]p2p.ID{4: "P1"},
+				received: map[int64]p2p.NodeID{4: "P1"},
 			},
 			wantResult: true,
 		},
@@ -1131,7 +1131,7 @@ func TestScAllBlocksProcessed(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]p2p.ID{2: "P1", 4: "P1"},
+				pending:     map[int64]p2p.NodeID{2: "P1", 4: "P1"},
 				pendingTime: map[int64]time.Time{2: now, 4: now},
 			},
 			wantResult: false,
@@ -1179,7 +1179,7 @@ func TestScNextHeightToSchedule(t *testing.T) {
 				initHeight:  1,
 				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]p2p.ID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
+				pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
 				pendingTime: map[int64]time.Time{1: now, 2: now, 3: now, 4: now},
 			},
 			wantHeight: -1,
@@ -1190,7 +1190,7 @@ func TestScNextHeightToSchedule(t *testing.T) {
 				initHeight: 1,
 				peers:      map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:       []int64{1, 2, 3, 4},
-				received:   map[int64]p2p.ID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
+				received:   map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
 			},
 			wantHeight: -1,
 		},
@@ -1209,7 +1209,7 @@ func TestScNextHeightToSchedule(t *testing.T) {
 				initHeight:  1,
 				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]p2p.ID{2: "P1"},
+				pending:     map[int64]p2p.NodeID{2: "P1"},
 				pendingTime: map[int64]time.Time{2: now},
 			},
 			wantHeight: 1,
@@ -1239,7 +1239,7 @@ func TestScSelectPeer(t *testing.T) {
 		name       string
 		fields     scTestParams
 		args       args
-		wantResult p2p.ID
+		wantResult p2p.NodeID
 		wantError  bool
 	}{
 		{
@@ -1307,7 +1307,7 @@ func TestScSelectPeer(t *testing.T) {
 					"P1": {height: 8, state: peerStateReady},
 					"P2": {height: 9, state: peerStateReady}},
 				allB: []int64{4, 5, 6, 7, 8, 9},
-				pending: map[int64]p2p.ID{
+				pending: map[int64]p2p.NodeID{
 					4: "P1", 6: "P1",
 					5: "P2",
 				},
@@ -1323,7 +1323,7 @@ func TestScSelectPeer(t *testing.T) {
 					"P1": {height: 15, state: peerStateReady},
 					"P3": {height: 15, state: peerStateReady}},
 				allB: []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
-				pending: map[int64]p2p.ID{
+				pending: map[int64]p2p.NodeID{
 					1: "P1", 2: "P1",
 					3: "P3", 4: "P3",
 					5: "P2", 6: "P2",
@@ -1373,6 +1373,9 @@ func checkScResults(t *testing.T, wantErr bool, err error, wantEvent Event, even
 		t.Errorf("error = %v, wantErr %v", err, wantErr)
 		return
 	}
+	if !assert.IsType(t, wantEvent, event) {
+		t.Log(fmt.Sprintf("Wrong type received, got: %v", event))
+	}
 	switch wantEvent := wantEvent.(type) {
 	case scPeerError:
 		assert.Equal(t, wantEvent.peerID, event.(scPeerError).peerID)
@@ -1389,7 +1392,7 @@ func TestScHandleBlockResponse(t *testing.T) {
 	now := time.Now()
 	block6FromP1 := bcBlockResponse{
 		time:   now.Add(time.Millisecond),
-		peerID: p2p.ID("P1"),
+		peerID: p2p.NodeID("P1"),
 		size:   100,
 		block:  makeScBlock(6),
 	}
@@ -1430,7 +1433,7 @@ func TestScHandleBlockResponse(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P2"},
+				pending:     map[int64]p2p.NodeID{6: "P2"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 			args:      args{event: block6FromP1},
@@ -1441,7 +1444,7 @@ func TestScHandleBlockResponse(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P1"},
+				pending:     map[int64]p2p.NodeID{6: "P1"},
 				pendingTime: map[int64]time.Time{6: now.Add(time.Second)},
 			},
 			args:      args{event: block6FromP1},
@@ -1452,11 +1455,11 @@ func TestScHandleBlockResponse(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P1"},
+				pending:     map[int64]p2p.NodeID{6: "P1"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 			args:      args{event: block6FromP1},
-			wantEvent: scBlockReceived{peerID: "P1", block: makeScBlock(6)},
+			wantEvent: scBlockReceived{peerID: "P1", block: block6FromP1.block},
 		},
 	}
 
@@ -1474,7 +1477,7 @@ func TestScHandleNoBlockResponse(t *testing.T) {
 	now := time.Now()
 	noBlock6FromP1 := bcNoBlockResponse{
 		time:   now.Add(time.Millisecond),
-		peerID: p2p.ID("P1"),
+		peerID: p2p.NodeID("P1"),
 		height: 6,
 	}
 
@@ -1510,14 +1513,14 @@ func TestScHandleNoBlockResponse(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P2"},
+				pending:     map[int64]p2p.NodeID{6: "P2"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 			wantEvent: noOpEvent{},
 			wantFields: scTestParams{
 				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P2"},
+				pending:     map[int64]p2p.NodeID{6: "P2"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 		},
@@ -1526,7 +1529,7 @@ func TestScHandleNoBlockResponse(t *testing.T) {
 			fields: scTestParams{
 				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
 				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P1"},
+				pending:     map[int64]p2p.NodeID{6: "P1"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 			wantEvent:  scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
@@ -1549,7 +1552,7 @@ func TestScHandleNoBlockResponse(t *testing.T) {
 func TestScHandleBlockProcessed(t *testing.T) {
 	now := time.Now()
 	processed6FromP1 := pcBlockProcessed{
-		peerID: p2p.ID("P1"),
+		peerID: p2p.NodeID("P1"),
 		height: 6,
 	}
 
@@ -1576,7 +1579,7 @@ func TestScHandleBlockProcessed(t *testing.T) {
 				initHeight:  6,
 				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
 				allB:        []int64{6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P1"},
+				pending:     map[int64]p2p.NodeID{6: "P1"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 			args:      args{event: processed6FromP1},
@@ -1588,7 +1591,7 @@ func TestScHandleBlockProcessed(t *testing.T) {
 				initHeight: 6,
 				peers:      map[string]*scPeer{"P1": {height: 7, state: peerStateReady}},
 				allB:       []int64{6, 7},
-				received:   map[int64]p2p.ID{6: "P1", 7: "P1"},
+				received:   map[int64]p2p.NodeID{6: "P1", 7: "P1"},
 			},
 			args:      args{event: processed6FromP1},
 			wantEvent: scFinishedEv{},
@@ -1599,8 +1602,8 @@ func TestScHandleBlockProcessed(t *testing.T) {
 				initHeight: 6,
 				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
 				allB:       []int64{6, 7, 8},
-				pending:    map[int64]p2p.ID{7: "P1", 8: "P1"},
-				received:   map[int64]p2p.ID{6: "P1"},
+				pending:    map[int64]p2p.NodeID{7: "P1", 8: "P1"},
+				received:   map[int64]p2p.NodeID{6: "P1"},
 			},
 			args:      args{event: processed6FromP1},
 			wantEvent: noOpEvent{},
@@ -1643,7 +1646,7 @@ func TestScHandleBlockVerificationFailure(t *testing.T) {
 				initHeight:  6,
 				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
 				allB:        []int64{6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P1"},
+				pending:     map[int64]p2p.NodeID{6: "P1"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
@@ -1655,7 +1658,7 @@ func TestScHandleBlockVerificationFailure(t *testing.T) {
 				initHeight:  6,
 				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}, "P2": {height: 8, state: peerStateReady}},
 				allB:        []int64{6, 7, 8},
-				pending:     map[int64]p2p.ID{6: "P1"},
+				pending:     map[int64]p2p.NodeID{6: "P1"},
 				pendingTime: map[int64]time.Time{6: now},
 			},
 			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
@@ -1667,7 +1670,7 @@ func TestScHandleBlockVerificationFailure(t *testing.T) {
 				initHeight: 6,
 				peers:      map[string]*scPeer{"P1": {height: 7, state: peerStateReady}},
 				allB:       []int64{6, 7},
-				received:   map[int64]p2p.ID{6: "P1", 7: "P1"},
+				received:   map[int64]p2p.NodeID{6: "P1", 7: "P1"},
 			},
 			args:      args{event: pcBlockVerificationFailure{height: 7, firstPeerID: "P1", secondPeerID: "P1"}},
 			wantEvent: scFinishedEv{},
@@ -1678,8 +1681,8 @@ func TestScHandleBlockVerificationFailure(t *testing.T) {
 				initHeight: 5,
 				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}, "P2": {height: 8, state: peerStateReady}},
 				allB:       []int64{5, 6, 7, 8},
-				pending:    map[int64]p2p.ID{7: "P1", 8: "P1"},
-				received:   map[int64]p2p.ID{5: "P1", 6: "P1"},
+				pending:    map[int64]p2p.NodeID{7: "P1", 8: "P1"},
+				received:   map[int64]p2p.NodeID{5: "P1", 6: "P1"},
 			},
 			args:      args{event: pcBlockVerificationFailure{height: 5, firstPeerID: "P1", secondPeerID: "P1"}},
 			wantEvent: noOpEvent{},
@@ -1694,8 +1697,8 @@ func TestScHandleBlockVerificationFailure(t *testing.T) {
 					"P3": {height: 8, state: peerStateReady},
 				},
 				allB:     []int64{5, 6, 7, 8},
-				pending:  map[int64]p2p.ID{7: "P1", 8: "P1"},
-				received: map[int64]p2p.ID{5: "P1", 6: "P1"},
+				pending:  map[int64]p2p.NodeID{7: "P1", 8: "P1"},
+				received: map[int64]p2p.NodeID{5: "P1", 6: "P1"},
 			},
 			args:      args{event: pcBlockVerificationFailure{height: 5, firstPeerID: "P1", secondPeerID: "P2"}},
 			wantEvent: noOpEvent{},
@@ -1714,7 +1717,7 @@ func TestScHandleBlockVerificationFailure(t *testing.T) {
 
 func TestScHandleAddNewPeer(t *testing.T) {
 	addP1 := bcAddNewPeer{
-		peerID: p2p.ID("P1"),
+		peerID: p2p.NodeID("P1"),
 	}
 	type args struct {
 		event bcAddNewPeer
@@ -1825,7 +1828,7 @@ func TestScHandleTryPrunePeer(t *testing.T) {
 				allB:        []int64{1, 2, 3, 4, 5, 6, 7},
 				peerTimeout: time.Second},
 			args:      args{event: pruneEv},
-			wantEvent: scPeersPruned{peers: []p2p.ID{"P4", "P5", "P6"}},
+			wantEvent: scPeersPruned{peers: []p2p.NodeID{"P4", "P5", "P6"}},
 		},
 		{
 			name: "mixed peers, finish after pruning",
@@ -1923,7 +1926,7 @@ func TestScHandleTrySchedule(t *testing.T) {
 					"P1": {height: 4, state: peerStateReady},
 					"P2": {height: 5, state: peerStateReady}},
 				allB: []int64{1, 2, 3, 4, 5},
-				pending: map[int64]p2p.ID{
+				pending: map[int64]p2p.NodeID{
 					1: "P1", 2: "P1",
 					3: "P2",
 				},
@@ -1941,7 +1944,7 @@ func TestScHandleTrySchedule(t *testing.T) {
 					"P1": {height: 8, state: peerStateReady},
 					"P3": {height: 8, state: peerStateReady}},
 				allB: []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending: map[int64]p2p.ID{
+				pending: map[int64]p2p.NodeID{
 					1: "P1", 2: "P1",
 					3: "P3", 4: "P3",
 					5: "P2", 6: "P2",
@@ -2043,6 +2046,8 @@ func TestScHandle(t *testing.T) {
 		priorityNormal
 	}
 
+	block1, block2, block3 := makeScBlock(1), makeScBlock(2), makeScBlock(3)
+
 	t0 := time.Now()
 	tick := make([]time.Time, 100)
 	for i := range tick {
@@ -2101,7 +2106,7 @@ func TestScHandle(t *testing.T) {
 						startTime:   now,
 						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
 						allB:        []int64{1, 2, 3},
-						pending:     map[int64]p2p.ID{1: "P1"},
+						pending:     map[int64]p2p.NodeID{1: "P1"},
 						pendingTime: map[int64]time.Time{1: tick[1]},
 						height:      1,
 					},
@@ -2113,7 +2118,7 @@ func TestScHandle(t *testing.T) {
 						startTime:   now,
 						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
 						allB:        []int64{1, 2, 3},
-						pending:     map[int64]p2p.ID{1: "P1", 2: "P1"},
+						pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1"},
 						pendingTime: map[int64]time.Time{1: tick[1], 2: tick[2]},
 						height:      1,
 					},
@@ -2125,67 +2130,67 @@ func TestScHandle(t *testing.T) {
 						startTime:   now,
 						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
 						allB:        []int64{1, 2, 3},
-						pending:     map[int64]p2p.ID{1: "P1", 2: "P1", 3: "P1"},
+						pending:     map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1"},
 						pendingTime: map[int64]time.Time{1: tick[1], 2: tick[2], 3: tick[3]},
 						height:      1,
 					},
 				},
 				{ // block response 1
-					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[4], size: 100, block: makeScBlock(1)}},
-					wantEvent: scBlockReceived{peerID: "P1", block: makeScBlock(1)},
+					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[4], size: 100, block: block1}},
+					wantEvent: scBlockReceived{peerID: "P1", block: block1},
 					wantSc: &scTestParams{
 						startTime:   now,
 						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[4]}},
 						allB:        []int64{1, 2, 3},
-						pending:     map[int64]p2p.ID{2: "P1", 3: "P1"},
+						pending:     map[int64]p2p.NodeID{2: "P1", 3: "P1"},
 						pendingTime: map[int64]time.Time{2: tick[2], 3: tick[3]},
-						received:    map[int64]p2p.ID{1: "P1"},
+						received:    map[int64]p2p.NodeID{1: "P1"},
 						height:      1,
 					},
 				},
 				{ // block response 2
-					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[5], size: 100, block: makeScBlock(2)}},
-					wantEvent: scBlockReceived{peerID: "P1", block: makeScBlock(2)},
+					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[5], size: 100, block: block2}},
+					wantEvent: scBlockReceived{peerID: "P1", block: block2},
 					wantSc: &scTestParams{
 						startTime:   now,
 						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[5]}},
 						allB:        []int64{1, 2, 3},
-						pending:     map[int64]p2p.ID{3: "P1"},
+						pending:     map[int64]p2p.NodeID{3: "P1"},
 						pendingTime: map[int64]time.Time{3: tick[3]},
-						received:    map[int64]p2p.ID{1: "P1", 2: "P1"},
+						received:    map[int64]p2p.NodeID{1: "P1", 2: "P1"},
 						height:      1,
 					},
 				},
 				{ // block response 3
-					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[6], size: 100, block: makeScBlock(3)}},
-					wantEvent: scBlockReceived{peerID: "P1", block: makeScBlock(3)},
+					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[6], size: 100, block: block3}},
+					wantEvent: scBlockReceived{peerID: "P1", block: block3},
 					wantSc: &scTestParams{
 						startTime: now,
 						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
 						allB:      []int64{1, 2, 3},
-						received:  map[int64]p2p.ID{1: "P1", 2: "P1", 3: "P1"},
+						received:  map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1"},
 						height:    1,
 					},
 				},
 				{ // processed block 1
-					args:      args{event: pcBlockProcessed{peerID: p2p.ID("P1"), height: 1}},
+					args:      args{event: pcBlockProcessed{peerID: p2p.NodeID("P1"), height: 1}},
 					wantEvent: noOpEvent{},
 					wantSc: &scTestParams{
 						startTime: now,
 						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
 						allB:      []int64{2, 3},
-						received:  map[int64]p2p.ID{2: "P1", 3: "P1"},
+						received:  map[int64]p2p.NodeID{2: "P1", 3: "P1"},
 						height:    2,
 					},
 				},
 				{ // processed block 2
-					args:      args{event: pcBlockProcessed{peerID: p2p.ID("P1"), height: 2}},
+					args:      args{event: pcBlockProcessed{peerID: p2p.NodeID("P1"), height: 2}},
 					wantEvent: scFinishedEv{},
 					wantSc: &scTestParams{
 						startTime: now,
 						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
 						allB:      []int64{3},
-						received:  map[int64]p2p.ID{3: "P1"},
+						received:  map[int64]p2p.NodeID{3: "P1"},
 						height:    3,
 					},
 				},
@@ -2201,7 +2206,7 @@ func TestScHandle(t *testing.T) {
 							"P1": {height: 4, state: peerStateReady, lastTouched: tick[6]},
 							"P2": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
 						allB:     []int64{1, 2, 3, 4},
-						received: map[int64]p2p.ID{1: "P1", 2: "P1", 3: "P1"},
+						received: map[int64]p2p.NodeID{1: "P1", 2: "P1", 3: "P1"},
 						height:   1,
 					},
 					args:      args{event: pcBlockVerificationFailure{height: 1, firstPeerID: "P1", secondPeerID: "P1"}},
@@ -2212,7 +2217,7 @@ func TestScHandle(t *testing.T) {
 							"P1": {height: 4, state: peerStateRemoved, lastTouched: tick[6]},
 							"P2": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
 						allB:     []int64{1, 2, 3},
-						received: map[int64]p2p.ID{},
+						received: map[int64]p2p.NodeID{},
 						height:   1,
 					},
 				},
@@ -2225,7 +2230,7 @@ func TestScHandle(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			var sc *scheduler
 			for i, step := range tt.steps {
-				// First step must always initialise the currentState as state.
+				// First step must always initialize the currentState as state.
 				if step.currentSc != nil {
 					sc = newTestScheduler(*step.currentSc)
 				}

buf.gen.yaml

@@ -1,9 +1,13 @@
-version: v1
+# The version of the generation template.
+# Required.
+# The only currently-valid value is v1beta1.
+version: v1beta1
+
+# The plugins to run.
 plugins:
+  # The name of the plugin.
   - name: gogofaster
-    out: ./proto/
-    opt:
-      - Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types
-      - Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration
-      - plugins=grpc
-      - paths=source_relative
+    # The the relative output directory.
+    out: proto
+    # Any options to provide to the plugin.
+    opt: Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,plugins=grpc,paths=source_relative

buf.work.yaml

@@ -1,3 +0,0 @@
-version: v1
-directories:
-  - proto

buf.yaml

@@ -1,3 +1,5 @@
+version: v1beta1
+
 build:
   roots:
     - proto