change lock

.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/codecov.yml

@@ -5,14 +5,19 @@ coverage:
   status:
     project:
       default:
-        threshold: 20%
-    patch: off
+        threshold: 1%
+    patch: on
     changes: off
 
 github_checks:
   annotations: false
 
-comment: false
+comment:
+  layout: "diff, files"
+  behavior: default
+  require_changes: no
+  require_base: no
+  require_head: yes
 
 ignore:
   - "docs"
@@ -20,6 +25,3 @@ ignore:
   - "scripts"
   - "**/*.pb.go"
   - "libs/pubsub/query/query.peg.go"
-  - "*.md"
-  - "*.rst"
-  - "*.yml"

.github/dependabot.yml

@@ -3,48 +3,25 @@ updates:
   - package-ecosystem: github-actions
     directory: "/"
     schedule:
-      interval: weekly
+      interval: daily
+      time: "11:00"
     open-pull-requests-limit: 10
-    labels:
-      - T:dependencies
-      - S:automerge
-
   - package-ecosystem: npm
     directory: "/docs"
     schedule:
-      interval: weekly
+      interval: daily
+      time: "11:00"
     open-pull-requests-limit: 10
-
-  ###################################
-  ##
-  ## Update All Go Dependencies
-
+    reviewers:
+      - fadeev
   - package-ecosystem: gomod
     directory: "/"
     schedule:
       interval: daily
-    target-branch: "master"
+      time: "11:00"
     open-pull-requests-limit: 10
+    reviewers:
+      - melekes
+      - tessr
     labels:
       - T:dependencies
-      - S:automerge
-
-  - package-ecosystem: gomod
-    directory: "/"
-    schedule:
-      interval: daily
-    target-branch: "v0.34.x"
-    open-pull-requests-limit: 10
-    labels:
-      - T:dependencies
-      - S:automerge
-
-  - package-ecosystem: gomod
-    directory: "/"
-    schedule:
-      interval: daily
-    target-branch: "v0.35.x"
-    open-pull-requests-limit: 10
-    labels:
-      - T:dependencies
-      - S:automerge

.github/mergify.yml

@@ -1,22 +1,13 @@
-queue_rules:
-  - name: default
-    conditions:
-      - base=master
-      - label=S:automerge
-
 pull_request_rules:
   - name: Automerge to master
     conditions:
       - 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
@@ -25,11 +16,3 @@ pull_request_rules:
       backport:
         branches:
           - v0.34.x
-  - name: backport patches to v0.35.x branch
-    conditions:
-      - base=master
-      - label=S:backport-to-v0.35.x
-    actions:
-      backport:
-        branches:
-          - v0.35.x

.github/workflows/build.yml

@@ -1,100 +0,0 @@
-name: Build
-# Tests runs different tests (test_abci_apps, test_abci_cli, test_apps)
-# This workflow runs on every push to master or release branch and  every pull requests
-# All jobs will pass without running if no *{.go, .mod, .sum} files have been modified
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - release/**
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        goarch: ["arm", "amd64"]
-        goos: ["linux"]
-    timeout-minutes: 5
-    steps:
-      - uses: actions/setup-go@v2
-        with:
-          go-version: "1.17"
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
-        with:
-          PATTERNS: |
-            **/**.go
-            "!test/"
-            go.mod
-            go.sum
-            Makefile
-      - name: install
-        run: GOOS=${{ matrix.goos }} GOARCH=${{ matrix.goarch }} make build
-        if: "env.GIT_DIFF != ''"
-
-  test_abci_cli:
-    runs-on: ubuntu-latest
-    needs: build
-    timeout-minutes: 5
-    steps:
-      - uses: actions/setup-go@v2
-        with:
-          go-version: "1.17"
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - name: install
-        run: make install_abci
-        if: "env.GIT_DIFF != ''"
-      - run: abci/tests/test_cli/test.sh
-        shell: bash
-        if: "env.GIT_DIFF != ''"
-
-  test_apps:
-    runs-on: ubuntu-latest
-    needs: build
-    timeout-minutes: 5
-    steps:
-      - uses: actions/setup-go@v2
-        with:
-          go-version: "1.17"
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - name: install
-        run: make install install_abci
-        if: "env.GIT_DIFF != ''"
-      - name: test_apps
-        run: test/app/test.sh
-        shell: bash
-        if: "env.GIT_DIFF != ''"
-
-  test_persistence:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/setup-go@v2
-        with:
-          go-version: "1.17"
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - run: make install
-      - run: test/persist/test_failure_indices.sh
-        shell: bash
-        # if: "env.GIT_DIFF != ''"

.github/workflows/coverage.yml

@@ -0,0 +1,127 @@
+name: Test Coverage
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - release/**
+
+jobs:
+  split-test-files:
+    runs-on: ubuntu-latest
+    steps:
+      - 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@v2
+        with:
+          name: "${{ github.sha }}-00"
+          path: ./pkgs.txt.part.00
+      - uses: actions/upload-artifact@v2
+        with:
+          name: "${{ github.sha }}-01"
+          path: ./pkgs.txt.part.01
+      - uses: actions/upload-artifact@v2
+        with:
+          name: "${{ github.sha }}-02"
+          path: ./pkgs.txt.part.02
+      - uses: actions/upload-artifact@v2
+        with:
+          name: "${{ github.sha }}-03"
+          path: ./pkgs.txt.part.03
+
+  build-linux:
+    name: Build
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        goarch: ["arm", "amd64"]
+    timeout-minutes: 5
+    steps:
+      - uses: actions/setup-go@v2
+        with:
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - name: install
+        run: GOOS=linux GOARCH=${{ matrix.goarch }} make build
+        if: "env.GIT_DIFF != ''"
+
+  tests:
+    runs-on: ubuntu-latest
+    needs: split-test-files
+    strategy:
+      fail-fast: false
+      matrix:
+        part: ["00", "01", "02", "03"]
+    steps:
+      - uses: actions/setup-go@v2
+        with:
+          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@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@v2
+        with:
+          name: "${{ github.sha }}-${{ matrix.part }}-coverage"
+          path: ./${{ matrix.part }}profile.out
+
+  upload-coverage-report:
+    runs-on: ubuntu-latest
+    needs: tests
+    steps:
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - uses: actions/download-artifact@v2
+        with:
+          name: "${{ github.sha }}-00-coverage"
+        if: env.GIT_DIFF
+      - uses: actions/download-artifact@v2
+        with:
+          name: "${{ github.sha }}-01-coverage"
+        if: env.GIT_DIFF
+      - uses: actions/download-artifact@v2
+        with:
+          name: "${{ github.sha }}-02-coverage"
+        if: env.GIT_DIFF
+      - 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@v1.5.0
+        with:
+          file: ./coverage.txt
+        if: env.GIT_DIFF

.github/workflows/docker.yml

@@ -1,7 +1,8 @@
-name: Docker
+name: Build & Push
 #  Build & Push rebuilds the tendermint docker image on every push to master and creation of tags
 # and pushes the image to https://hub.docker.com/r/interchainio/simapp/tags
 on:
+  pull_request:
   push:
     branches:
       - master
@@ -13,7 +14,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2.4.0
+      - uses: actions/checkout@v2.3.4
       - name: Prepare
         id: prep
         run: |
@@ -38,18 +39,18 @@ jobs:
         with:
           platforms: all
 
-      - name: Set up Docker Build
-        uses: docker/setup-buildx-action@v1.6.0
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1.3.0
 
       - name: Login to DockerHub
         if: ${{ github.event_name != 'pull_request' }}
-        uses: docker/login-action@v1.10.0
+        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.7.0
+        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-nightly-34x.yml

@@ -17,15 +17,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        group: ['00', '01']
+        group: ['00', '01', '02', '03']
     runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
+          go-version: '1.16'
 
-      - uses: actions/checkout@v2.4.0
+      - uses: actions/checkout@v2.3.4
         with:
           ref: 'v0.34.x'
 
@@ -37,7 +37,7 @@ jobs:
       - name: Generate testnets
         working-directory: test/e2e
         # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 2 -d networks/nightly
+        run: ./build/generator -g 4 -d networks/nightly
 
       - name: Run testnets in group ${{ matrix.group }}
         working-directory: test/e2e
@@ -49,7 +49,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Notify Slack on failure
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
         env:
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_CHANNEL: tendermint-internal
@@ -65,7 +65,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Notify Slack on success
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
         env:
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_CHANNEL: tendermint-internal

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

@@ -1,76 +0,0 @@
-# Runs randomly generated E2E testnets nightly on v0.35.x.
-
-# !! If you change something in this file, you probably want
-# to update the e2e-nightly-master workflow as well!
-
-name: e2e-nightly-35x
-on:
-  workflow_dispatch: # allow running workflow manually
-  schedule:
-    - cron: '0 2 * * *'
-
-jobs:
-  e2e-nightly-test:
-    # Run parallel jobs for the listed testnet groups (must match the
-    # ./build/generator -g flag)
-    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@v2
-        with:
-          go-version: '1.17'
-
-      - uses: actions/checkout@v2.4.0
-        with:
-          ref: 'v0.35.x'
-
-      - 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/${{ matrix.p2p }} -p ${{ matrix.p2p }}
-
-      - name: Run ${{ matrix.p2p }} p2p testnets in group ${{ matrix.group }}
-        working-directory: test/e2e
-        run: ./run-multiple.sh networks/nightly/${{ matrix.p2p }}/*-group${{ matrix.group }}-*.toml
-
-  e2e-nightly-fail-2:
-    needs: e2e-nightly-test
-    if: ${{ failure() }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify Slack on failure
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
-        env:
-          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
-          SLACK_CHANNEL: tendermint-internal
-          SLACK_USERNAME: Nightly E2E Tests
-          SLACK_ICON_EMOJI: ':skull:'
-          SLACK_COLOR: danger
-          SLACK_MESSAGE: Nightly E2E tests failed on v0.35.x
-          SLACK_FOOTER: ''
-
-  e2e-nightly-success: # may turn this off once they seem to pass consistently
-    needs: e2e-nightly-test
-    if: ${{ success() }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify Slack on success
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
-        env:
-          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
-          SLACK_CHANNEL: tendermint-internal
-          SLACK_USERNAME: Nightly E2E Tests
-          SLACK_ICON_EMOJI: ':white_check_mark:'
-          SLACK_COLOR: good
-          SLACK_MESSAGE: Nightly E2E tests passed on v0.35.x
-          SLACK_FOOTER: ''

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

@@ -10,43 +10,44 @@ on:
     - cron: '0 2 * * *'
 
 jobs:
-  e2e-nightly-test:
+  e2e-nightly-test-2:
     # Run parallel jobs for the listed testnet groups (must match the
     # ./build/generator -g flag)
     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@v2
         with:
-          go-version: '1.17'
+          go-version: '1.16'
 
-      - uses: actions/checkout@v2.4.0
+      - uses: actions/checkout@v2.3.4
 
       - 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
+        run: make -j2 docker generator runner
 
       - 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 ${{ matrix.p2p }} p2p testnets
+      - 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
+    needs: e2e-nightly-test-2
     if: ${{ failure() }}
     runs-on: ubuntu-latest
     steps:
       - name: Notify Slack on failure
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
         env:
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_CHANNEL: tendermint-internal
@@ -57,12 +58,12 @@ jobs:
           SLACK_FOOTER: ''
 
   e2e-nightly-success: # may turn this off once they seem to pass consistently
-    needs: e2e-nightly-test
+    needs: e2e-nightly-test-2
     if: ${{ success() }}
     runs-on: ubuntu-latest
     steps:
       - name: Notify Slack on success
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
         env:
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_CHANNEL: tendermint-internal

.github/workflows/e2e.yml

@@ -16,9 +16,9 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
+          go-version: '1.16'
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
@@ -28,11 +28,15 @@ jobs:
       - name: Build
         working-directory: test/e2e
         # Run two make jobs in parallel, since we can't run steps in parallel.
-        run: make -j2 docker runner tests
+        run: make -j2 docker runner
         if: "env.GIT_DIFF != ''"
 
       - name: Run CI testnet
         working-directory: test/e2e
-        run: ./run-multiple.sh networks/ci.toml
+        run: ./build/runner -f networks/ci.toml
         if: "env.GIT_DIFF != ''"
 
+      - name: Emit logs on failure
+        if: ${{ failure() }}
+        working-directory: test/e2e
+        run: ./build/runner -f networks/ci.toml logs

.github/workflows/fuzz-nightly.yml

@@ -1,5 +1,5 @@
 # Runs fuzzing nightly.
-name: Fuzz Tests
+name: fuzz-nightly
 on:
   workflow_dispatch: # allow running workflow manually
   schedule:
@@ -15,9 +15,9 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
+          go-version: '1.16'
 
-      - uses: actions/checkout@v2.4.0
+      - uses: actions/checkout@v2.3.4
 
       - name: Install go-fuzz
         working-directory: test/fuzz
@@ -28,6 +28,16 @@ jobs:
         run: timeout -s SIGINT --preserve-status 10m make fuzz-mempool
         continue-on-error: true
 
+      - name: Fuzz p2p-addrbook
+        working-directory: test/fuzz
+        run: timeout -s SIGINT --preserve-status 10m make fuzz-p2p-addrbook
+        continue-on-error: true
+
+      - name: Fuzz p2p-pex
+        working-directory: test/fuzz
+        run: timeout -s SIGINT --preserve-status 10m make fuzz-p2p-pex
+        continue-on-error: true
+
       - name: Fuzz p2p-sc
         working-directory: test/fuzz
         run: timeout -s SIGINT --preserve-status 10m make fuzz-p2p-sc
@@ -66,7 +76,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Notify Slack if any crashers
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
         env:
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_CHANNEL: tendermint-internal

.github/workflows/janitor.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 3
     steps:
-      - uses: styfle/cancel-workflow-action@0.9.1
+      - uses: styfle/cancel-workflow-action@0.9.0
         with:
           workflow_id: 1041851,1401230,2837803
           access_token: ${{ github.token }}

.github/workflows/jepsen.yml

@@ -46,7 +46,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the Jepsen repository
-        uses: actions/checkout@v2.4.0
+        uses: actions/checkout@v2.3.4
         with:
           repository: 'tendermint/jepsen'
 

.github/workflows/linkchecker.yml

@@ -6,7 +6,7 @@ jobs:
   markdown-link-check:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2.4.0
-      - uses: gaurav-nelson/github-action-markdown-link-check@1.0.13
+      - 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,8 +13,8 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 8
     steps:
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
@@ -23,7 +23,7 @@ jobs:
       - 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.42.1
+          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@v2.4.0
+        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.yml

@@ -0,0 +1,23 @@
+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"
+jobs:
+  proto-lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 4
+    steps:
+      - 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@v2.3.4
+      - name: check-breakage
+        run: make proto-check-breaking-ci

.github/workflows/release.yml

@@ -2,7 +2,7 @@ name: "Release"
 
 on:
   push:
-    branches:
+    branches: 
       - "RC[0-9]/**"
     tags:
       - "v[0-9]+.[0-9]+.[0-9]+" # Push events to matching v*, i.e. v1.0, v20.15.10
@@ -12,13 +12,16 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2.4.0
+        uses: actions/checkout@v2.3.4
         with:
           fetch-depth: 0
 
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
+          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: Build
         uses: goreleaser/goreleaser-action@v2
@@ -32,6 +35,6 @@ jobs:
         if: startsWith(github.ref, 'refs/tags/')
         with:
           version: latest
-          args: release --rm-dist
+          args: release --rm-dist --release-notes=../release_notes.md
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/stale.yml

@@ -7,14 +7,12 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v4
+      - 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
     recent activity. It will be closed if no further activity occurs. Thank you
     for your contributions."
-          days-before-stale: -1
-          days-before-close: -1
-          days-before-pr-stale: 10
-          days-before-pr-close: 4
+          days-before-stale: 10
+          days-before-close: 4
           exempt-pr-labels: "S:wip"

.github/workflows/tests.yml

@@ -1,82 +1,138 @@
-name: Test
+name: Tests
+# Tests runs different tests (test_abci_apps, test_abci_cli, test_apps)
+# This workflow runs on every push to master or release branch and  every pull requests
+# All jobs will pass without running if no *{.go, .mod, .sum} files have been modified
 on:
   pull_request:
   push:
-    paths:
-      - "**.go"
     branches:
       - master
       - release/**
 
 jobs:
-  tests:
+  build:
+    name: Build
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        part: ["00", "01", "02", "03"]
+    timeout-minutes: 5
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.17"
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
-            "!test/"
             go.mod
             go.sum
-            Makefile
-      - name: Run Go Tests
-        run: |
-          make test-group-${{ matrix.part }} NUM_SPLIT=4
-        if: env.GIT_DIFF
-      - uses: actions/upload-artifact@v2
+      - name: install
+        run: make install install_abci
+        if: "env.GIT_DIFF != ''"
+      - uses: actions/cache@v2.1.5
         with:
-          name: "${{ github.sha }}-${{ matrix.part }}-coverage"
-          path: ./build/${{ matrix.part }}.profile.out
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+        if: env.GIT_DIFF
+      # Cache binaries for use by other jobs
+      - uses: actions/cache@v2.1.5
+        with:
+          path: ~/go/bin
+          key: ${{ runner.os }}-${{ github.sha }}-tm-binary
+        if: env.GIT_DIFF
 
-  upload-coverage-report:
+  test_abci_apps:
     runs-on: ubuntu-latest
-    needs: tests
+    needs: build
+    timeout-minutes: 5
     steps:
-      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v5
+      - uses: actions/setup-go@v2
+        with:
+          go-version: "1.16"
+      - uses: actions/checkout@v2.3.4
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
-            "!test/"
             go.mod
             go.sum
-            Makefile
-      - uses: actions/download-artifact@v2
+      - uses: actions/cache@v2.1.5
         with:
-          name: "${{ github.sha }}-00-coverage"
+          path: ~/go/pkg/mod
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
         if: env.GIT_DIFF
-      - uses: actions/download-artifact@v2
+      - uses: actions/cache@v2.1.5
         with:
-          name: "${{ github.sha }}-01-coverage"
+          path: ~/go/bin
+          key: ${{ runner.os }}-${{ github.sha }}-tm-binary
         if: env.GIT_DIFF
-      - uses: actions/download-artifact@v2
-        with:
-          name: "${{ github.sha }}-02-coverage"
+      - name: test_abci_apps
+        run: abci/tests/test_app/test.sh
+        shell: bash
         if: env.GIT_DIFF
-      - uses: actions/download-artifact@v2
-        with:
-          name: "${{ github.sha }}-03-coverage"
-        if: env.GIT_DIFF
-      - run: |
-          cat ./*profile.out | grep -v "mode: set" >> coverage.txt
-        if: env.GIT_DIFF
-      - uses: codecov/codecov-action@v2.1.0
-        with:
-          file: ./coverage.txt
-        if: env.GIT_DIFF
-  
-  test_persistence:
+
+  test_abci_cli:
     runs-on: ubuntu-latest
+    needs: build
+    timeout-minutes: 5
     steps:
-      - name: run persistence tests
-        working-directory: test/persist
-        run: ./test_failure_indices.sh
+      - uses: actions/setup-go@v2
+        with:
+          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@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@v2.1.5
+        with:
+          path: ~/go/bin
+          key: ${{ runner.os }}-${{ github.sha }}-tm-binary
+        if: env.GIT_DIFF
+      - run: abci/tests/test_cli/test.sh
+        shell: bash
+        if: env.GIT_DIFF
+
+  test_apps:
+    runs-on: ubuntu-latest
+    needs: build
+    timeout-minutes: 5
+    steps:
+      - uses: actions/setup-go@v2
+        with:
+          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@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@v2.1.5
+        with:
+          path: ~/go/bin
+          key: ${{ runner.os }}-${{ github.sha }}-tm-binary
+        if: env.GIT_DIFF
+      - name: test_apps
+        run: test/app/test.sh
+        shell: bash
+        if: env.GIT_DIFF

.gitignore

@@ -15,7 +15,7 @@
 .vagrant
 .vendor-new/
 .vscode/
-abci/abci-cli
+abci-cli
 addrbook.json
 artifacts/*
 build/*
@@ -24,8 +24,6 @@ docs/.vuepress/dist
 docs/_build
 docs/dist
 docs/node_modules/
-docs/spec
-docs/.vuepress/public/rpc
 index.html.md
 libs/pubsub/query/fuzz_test/output
 profile\.out
@@ -47,10 +45,3 @@ test/fuzz/**/corpus
 test/fuzz/**/crashers
 test/fuzz/**/suppressions
 test/fuzz/**/*.zip
-proto/tendermint/blocksync/types.proto
-proto/tendermint/consensus/types.proto
-proto/tendermint/mempool/*.proto
-proto/tendermint/p2p/*.proto
-proto/tendermint/statesync/*.proto
-proto/tendermint/types/*.proto
-proto/tendermint/version/*.proto

.golangci.yml

@@ -1,35 +1,32 @@
 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
-    # - maligned
+    - lll
     - misspell
+    # - maligned
     - nakedret
-    - nolintlint
     - prealloc
+    - scopelint
     - staticcheck
     - structcheck
     - stylecheck
@@ -40,12 +37,17 @@ linters:
     - varcheck
     # - whitespace
     # - wsl
+    # - gocognit
+    - nolintlint
 
 issues:
   exclude-rules:
     - path: _test\.go
       linters:
         - gosec
+    - linters:
+        - lll
+      source: "https://"
   max-same-issues: 50
 
 linters-settings:

CHANGELOG.md

@@ -1,260 +1,14 @@
 # Changelog
 
-Friendly reminder: We have a [bug bounty program](https://hackerone.com/cosmos).
-
-## v0.35.0
-
-November 4, 2021
-
-Special thanks to external contributors on this release: @JayT106,
-@bipulprasad, @alessio, @Yawning, @silasdavis, @cuonglm, @tanyabouman,
-@JoeKash, @githubsands, @jeebster, @crypto-facs, @liamsi, and @gotjoshua
-
-### FEATURES
-
-- [cli] [#7033](https://github.com/tendermint/tendermint/pull/7033) Add a `rollback` command to rollback to the previous tendermint state in the event of an incorrect app hash. (@cmwaters)
-- [config] [\#7174](https://github.com/tendermint/tendermint/pull/7174) expose ability to write config to arbitrary paths. (@tychoish)
-- [mempool, rpc] [\#7065](https://github.com/tendermint/tendermint/pull/7065) add removetx rpc method (backport of #7047) (@tychoish).
-- [\#6982](https://github.com/tendermint/tendermint/pull/6982) tendermint binary has built-in suppport for running the e2e application (with state sync support) (@cmwaters).
-- [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](https://github.com/tendermint/tendermint/pull/6329) Don't cap page size in unsafe mode (@gotjoshua, @cmwaters)
-- [pex] [\#6305](https://github.com/tendermint/tendermint/pull/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](https://github.com/tendermint/tendermint/pull/6376) Enable sr25519 as a validator key type
-- [mempool] [\#6466](https://github.com/tendermint/tendermint/pull/6466) Introduction of a prioritized mempool. (@alexanderbez)
-  - `Priority` and `Sender` have been introduced into the `ResponseCheckTx` type, where the `priority` will determine the prioritization of
-  the transaction when a proposer reaps transactions for a block proposal. The `sender` field acts as an index.
-  - Operators may toggle between the legacy mempool reactor, `v0`, and the new prioritized reactor, `v1`, by setting the
-  `mempool.version` configuration, where `v1` is the default configuration.
-  - Applications that do not specify a priority, i.e. zero, will have transactions reaped by the order in which they are received by the node.
-  - Transactions are gossiped in FIFO order as they are in `v0`.
-- [config/indexer] [\#6411](https://github.com/tendermint/tendermint/pull/6411) Introduce support for custom event indexing data sources, specifically PostgreSQL. (@JayT106)
-- [blocksync/event] [\#6619](https://github.com/tendermint/tendermint/pull/6619) Emit blocksync status event when switching consensus/blocksync (@JayT106)
-- [statesync/event] [\#6700](https://github.com/tendermint/tendermint/pull/6700) Emit statesync status start/end event (@JayT106)
-- [inspect] [\#6785](https://github.com/tendermint/tendermint/pull/6785) Add a new `inspect` command for introspecting the state and block store of a crashed tendermint node. (@williambanfield)
-
-### BUG FIXES
-
-- [\#7106](https://github.com/tendermint/tendermint/pull/7106) Revert mutex change to ABCI Clients (@tychoish).
-- [\#7142](https://github.com/tendermint/tendermint/pull/7142) mempool: remove panic when recheck-tx was not sent to ABCI application (@williambanfield).
-- [consensus]: [\#7060](https://github.com/tendermint/tendermint/pull/7060)
-  wait until peerUpdates channel is closed to close remaining peers (@williambanfield)
-- [privval] [\#5638](https://github.com/tendermint/tendermint/pull/5638) Increase read/write timeout to 5s and calculate ping interval based on it (@JoeKash)
-- [evidence] [\#6375](https://github.com/tendermint/tendermint/pull/6375) Fix bug with inconsistent LightClientAttackEvidence hashing (cmwaters)
-- [rpc] [\#6507](https://github.com/tendermint/tendermint/pull/6507) Ensure RPC client can handle URLs without ports (@JayT106)
-- [statesync] [\#6463](https://github.com/tendermint/tendermint/pull/6463) Adds Reverse Sync feature to fetch historical light blocks after state sync in order to verify any evidence (@cmwaters)
-- [blocksync] [\#6590](https://github.com/tendermint/tendermint/pull/6590) Update the metrics during blocksync (@JayT106)
-
-### BREAKING CHANGES
-
-- Go API
-
-  - [crypto/armor]: [\#6963](https://github.com/tendermint/tendermint/pull/6963) remove package which is unused, and based on
-    deprecated fundamentals. Downstream users should maintain this
-    library. (@tychoish)
-  - [state] [store] [proxy] [rpc/core]: [\#6937](https://github.com/tendermint/tendermint/pull/6937) move packages to
-    `internal` to prevent consumption of these internal APIs by
-    external users. (@tychoish)
-  - [pubsub] [\#6634](https://github.com/tendermint/tendermint/pull/6634) The `Query#Matches` method along with other pubsub methods, now accepts a `[]abci.Event` instead of `map[string][]string`. (@alexanderbez)
-  - [p2p] [\#6618](https://github.com/tendermint/tendermint/pull/6618) [\#6583](https://github.com/tendermint/tendermint/pull/6583) Move `p2p.NodeInfo`, `p2p.NodeID` and `p2p.NetAddress` into `types` to support use in external packages. (@tychoish)
-  - [node] [\#6540](https://github.com/tendermint/tendermint/pull/6540) Reduce surface area of the `node` package by making most of the implementation details private. (@tychoish)
-  - [p2p] [\#6547](https://github.com/tendermint/tendermint/pull/6547) Move the entire `p2p` package and all reactor implementations into `internal`.  (@tychoish)
-  - [libs/log] [\#6534](https://github.com/tendermint/tendermint/pull/6534) Remove the existing custom Tendermint logger backed by go-kit. The logging interface, `Logger`, remains. Tendermint still provides a default logger backed by the performant zerolog logger. (@alexanderbez)
-  - [libs/time] [\#6495](https://github.com/tendermint/tendermint/pull/6495) Move types/time to libs/time to improve consistency. (@tychoish)
-  - [mempool] [\#6529](https://github.com/tendermint/tendermint/pull/6529) The `Context` field has been removed from the `TxInfo` type. `CheckTx` now requires a `Context` argument. (@alexanderbez)
-  - [abci/client, proxy] [\#5673](https://github.com/tendermint/tendermint/pull/5673) `Async` funcs return an error, `Sync` and `Async` funcs accept `context.Context` (@melekes)
-  - [p2p] Remove unused function `MakePoWTarget`. (@erikgrinaker)
-  - [libs/bits] [\#5720](https://github.com/tendermint/tendermint/pull/5720) Validate `BitArray` in `FromProto`, which now returns an error (@melekes)
-  - [proto/p2p] Rename `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](https://github.com/tendermint/tendermint/pull/5848) Remove block store state in favor of using the db iterators directly (@cmwaters)
-  - [state] [\#5864](https://github.com/tendermint/tendermint/pull/5864) Use an iterator when pruning state (@cmwaters)
-  - [types] [\#6023](https://github.com/tendermint/tendermint/pull/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](https://github.com/tendermint/tendermint/pull/6054) Move `MaxRetryAttempt` option from client to provider.
-	- `NewWithOptions` now sets the max retry attempts and timeouts (@cmwaters)
-  - [all] [\#6077](https://github.com/tendermint/tendermint/pull/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 blocksync v2
-  - [rpc/client/http] [\#6176](https://github.com/tendermint/tendermint/pull/6176) Remove `endpoint` arg from `New`, `NewWithTimeout` and `NewWithClient` (@melekes)
-  - [rpc/client/http] [\#6176](https://github.com/tendermint/tendermint/pull/6176) Unexpose `WSEvents` (@melekes)
-  - [rpc/jsonrpc/client/ws_client] [\#6176](https://github.com/tendermint/tendermint/pull/6176) `NewWS` no longer accepts options (use `NewWSWithOptions` and `OnReconnect` funcs to configure the client) (@melekes)
-  - [internal/libs] [\#6366](https://github.com/tendermint/tendermint/pull/6366) Move `autofile`, `clist`,`fail`,`flowrate`, `protoio`, `sync`, `tempfile`, `test` and `timer` lib packages to an internal folder
-  - [libs/rand] [\#6364](https://github.com/tendermint/tendermint/pull/6364) Remove most of libs/rand in favour of standard lib's `math/rand` (@liamsi)
-  - [mempool] [\#6466](https://github.com/tendermint/tendermint/pull/6466) The original mempool reactor has been versioned as `v0` and moved to a sub-package under the root `mempool` package.
-	Some core types have been kept in the `mempool` package such as `TxCache` and it's implementations, the `Mempool` interface itself
-	and `TxInfo`. (@alexanderbez)
-  - [crypto/sr25519] [\#6526](https://github.com/tendermint/tendermint/pull/6526) Do not re-execute the Ed25519-style key derivation step when doing signing and verification.  The derivation is now done once and only once.  This breaks `sr25519.GenPrivKeyFromSecret` output compatibility. (@Yawning)
-  - [types] [\#6627](https://github.com/tendermint/tendermint/pull/6627) Move `NodeKey` to types to make the type public.
-  - [config] [\#6627](https://github.com/tendermint/tendermint/pull/6627) Extend `config` to contain methods `LoadNodeKeyID` and `LoadorGenNodeKeyID`
-  - [blocksync] [\#6755](https://github.com/tendermint/tendermint/pull/6755) Rename `FastSync` and `Blockchain` package to `BlockSync` (@cmwaters)
-
-- CLI/RPC/Config
-
-  - [pubsub/events] [\#6634](https://github.com/tendermint/tendermint/pull/6634) The `ResultEvent.Events` field is now of type `[]abci.Event` preserving event order instead of `map[string][]string`. (@alexanderbez)
-  - [config] [\#5598](https://github.com/tendermint/tendermint/pull/5598) The `test_fuzz` and `test_fuzz_config` P2P settings have been removed. (@erikgrinaker)
-  - [config] [\#5728](https://github.com/tendermint/tendermint/pull/5728) `fastsync.version = "v1"` is no longer supported (@melekes)
-  - [cli] [\#5772](https://github.com/tendermint/tendermint/pull/5772) `gen_node_key` prints JSON-encoded `NodeKey` rather than ID and does not save it to `node_key.json` (@melekes)
-  - [cli] [\#5777](https://github.com/tendermint/tendermint/pull/5777) use hyphen-case instead of snake_case for all cli commands and config parameters (@cmwaters)
-  - [rpc] [\#6019](https://github.com/tendermint/tendermint/pull/6019) standardise RPC errors and return the correct status code (@bipulprasad & @cmwaters)
-  - [rpc] [\#6168](https://github.com/tendermint/tendermint/pull/6168) Change default sorting to desc for `/tx_search` results (@melekes)
-  - [cli] [\#6282](https://github.com/tendermint/tendermint/pull/6282) User must specify the node mode when using `tendermint init` (@cmwaters)
-  - [state/indexer] [\#6382](https://github.com/tendermint/tendermint/pull/6382) reconstruct indexer, move txindex into the indexer package (@JayT106)
-  - [cli] [\#6372](https://github.com/tendermint/tendermint/pull/6372) Introduce `BootstrapPeers` as part of the new p2p stack. Peers to be connected on  startup (@cmwaters)
-  - [config] [\#6462](https://github.com/tendermint/tendermint/pull/6462) Move `PrivValidator` configuration out of `BaseConfig` into its own section. (@tychoish)
-  - [rpc] [\#6610](https://github.com/tendermint/tendermint/pull/6610) Add MaxPeerBlockHeight into /status rpc call (@JayT106)
-  - [blocksync/rpc] [\#6620](https://github.com/tendermint/tendermint/pull/6620) Add TotalSyncedTime & RemainingTime to SyncInfo in /status RPC  (@JayT106)
-  - [rpc/grpc] [\#6725](https://github.com/tendermint/tendermint/pull/6725) Mark gRPC in the RPC layer as deprecated.
-  - [blocksync/v2] [\#6730](https://github.com/tendermint/tendermint/pull/6730) Fast Sync v2 is deprecated, please use v0
-  - [rpc] Add genesis_chunked method to support paginated and parallel fetching of large genesis documents.
-  - [rpc/jsonrpc/server] [\#6785](https://github.com/tendermint/tendermint/pull/6785) `Listen` function updated to take an `int` argument, `maxOpenConnections`, instead of an entire config object. (@williambanfield)
-  - [rpc] [\#6820](https://github.com/tendermint/tendermint/pull/6820) Update RPC methods to reflect changes in the p2p layer, disabling support for `UnsafeDialPeers` and `UnsafeDialPeers` when used with the new p2p layer, and changing the response format of the peer list in `NetInfo` for all users.
-  - [cli] [\#6854](https://github.com/tendermint/tendermint/pull/6854) Remove deprecated snake case commands. (@tychoish)
-  - [tools] [\#6498](https://github.com/tendermint/tendermint/pull/6498) Set OS home dir to instead of the hardcoded PATH. (@JayT106)
-  - [cli/indexer] [\#6676](https://github.com/tendermint/tendermint/pull/6676) Reindex events command line tooling. (@JayT106)
-
-- Apps
-
-  - [ABCI] [\#6408](https://github.com/tendermint/tendermint/pull/6408) Change the `key` and `value` fields from `[]byte` to `string` in the `EventAttribute` type. (@alexanderbez)
-  - [ABCI] [\#5447](https://github.com/tendermint/tendermint/pull/5447) Remove `SetOption` method from `ABCI.Client` interface
-  - [ABCI] [\#5447](https://github.com/tendermint/tendermint/pull/5447) Reset `Oneof` indexes for  `Request` and `Response`.
-  - [ABCI] [\#5818](https://github.com/tendermint/tendermint/pull/5818) Use protoio for msg length delimitation. Migrates from int64 to uint64 length delimiters.
-  - [ABCI] [\#3546](https://github.com/tendermint/tendermint/pull/3546) Add `mempool_error` field to `ResponseCheckTx`. This field will contain an error string if Tendermint encountered an error while adding a transaction to the mempool. (@williambanfield)
-  - [Version] [\#6494](https://github.com/tendermint/tendermint/pull/6494) `TMCoreSemVer` has been renamed to `TMVersion`.
-	- It is not required any longer to set ldflags to set version strings
-  - [abci/counter] [\#6684](https://github.com/tendermint/tendermint/pull/6684) Delete counter example app
-
-- Data Storage
-  - [store/state/evidence/light] [\#5771](https://github.com/tendermint/tendermint/pull/5771) Use an order-preserving varint key encoding (@cmwaters)
-  - [mempool] [\#6396](https://github.com/tendermint/tendermint/pull/6396) Remove mempool's write ahead log (WAL), (previously unused by the tendermint code). (@tychoish)
-  - [state] [\#6541](https://github.com/tendermint/tendermint/pull/6541) Move pruneBlocks from consensus/state to state/execution. (@JayT106)
-
-### IMPROVEMENTS
-
-- [libs/log] Console log formatting changes as a result of [\#6534](https://github.com/tendermint/tendermint/pull/6534) and [\#6589](https://github.com/tendermint/tendermint/pull/6589). (@tychoish)
-- [statesync] [\#6566](https://github.com/tendermint/tendermint/pull/6566) Allow state sync fetchers and request timeout to be configurable. (@alexanderbez)
-- [types] [\#6478](https://github.com/tendermint/tendermint/pull/6478) Add `block_id` to `newblock` event (@jeebster)
-- [crypto/ed25519] [\#5632](https://github.com/tendermint/tendermint/pull/5632) Adopt zip215 `ed25519` verification. (@marbar3778)
-- [crypto/ed25519] [\#6526](https://github.com/tendermint/tendermint/pull/6526) Use [curve25519-voi](https://github.com/oasisprotocol/curve25519-voi) for `ed25519` signing and verification. (@Yawning)
-- [crypto/sr25519] [\#6526](https://github.com/tendermint/tendermint/pull/6526) Use [curve25519-voi](https://github.com/oasisprotocol/curve25519-voi) for `sr25519` signing and verification. (@Yawning)
-- [privval] [\#5603](https://github.com/tendermint/tendermint/pull/5603) Add `--key` to `init`, `gen_validator`, `testnet` & `unsafe_reset_priv_validator` for use in generating `secp256k1` keys.
-- [privval] [\#5725](https://github.com/tendermint/tendermint/pull/5725) Add gRPC support to private validator.
-- [privval] [\#5876](https://github.com/tendermint/tendermint/pull/5876) `tendermint show-validator` will query the remote signer if gRPC is being used (@marbar3778)
-- [abci/client] [\#5673](https://github.com/tendermint/tendermint/pull/5673) `Async` requests return an error if queue is full (@melekes)
-- [mempool] [\#5673](https://github.com/tendermint/tendermint/pull/5673) Cancel `CheckTx` requests if RPC client disconnects or times out (@melekes)
-- [abci] [\#5706](https://github.com/tendermint/tendermint/pull/5706) Added `AbciVersion` to `RequestInfo` allowing applications to check ABCI version when connecting to Tendermint. (@marbar3778)
-- [blocksync/v1] [\#5728](https://github.com/tendermint/tendermint/pull/5728) Remove blocksync v1 (@melekes)
-- [blocksync/v0] [\#5741](https://github.com/tendermint/tendermint/pull/5741) Relax termination conditions and increase sync timeout (@melekes)
-- [cli] [\#5772](https://github.com/tendermint/tendermint/pull/5772) `gen_node_key` output now contains node ID (`id` field) (@melekes)
-- [blocksync/v2] [\#5774](https://github.com/tendermint/tendermint/pull/5774) Send status request when new peer joins (@melekes)
-- [store] [\#5888](https://github.com/tendermint/tendermint/pull/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](https://github.com/tendermint/tendermint/pull/5987) and [\#5792](https://github.com/tendermint/tendermint/pull/5792) Remove the `time_iota_ms` consensus parameter. Merge `tmproto.ConsensusParams` and `abci.ConsensusParams`. (@marbar3778, @valardragon)
-- [types] [\#5994](https://github.com/tendermint/tendermint/pull/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](https://github.com/tendermint/tendermint/pull/6163) Do not drop events even if the `out` channel is full (@melekes)
-- [node] [\#6059](https://github.com/tendermint/tendermint/pull/6059) Validate and complete genesis doc before saving to state store (@silasdavis)
-- [state] [\#6067](https://github.com/tendermint/tendermint/pull/6067) Batch save state data (@githubsands & @cmwaters)
-- [crypto] [\#6120](https://github.com/tendermint/tendermint/pull/6120) Implement batch verification interface for ed25519 and sr25519. (@marbar3778)
-- [types] [\#6120](https://github.com/tendermint/tendermint/pull/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](https://github.com/tendermint/tendermint/pull/6185) Return error on `LoadFilePV`, `LoadFilePVEmptyState`. Allows for better programmatic control of Tendermint.
-- [privval] [\#6240](https://github.com/tendermint/tendermint/pull/6240) Add `context.Context` to privval interface.
-- [rpc] [\#6265](https://github.com/tendermint/tendermint/pull/6265) set cache control in http-rpc response header (@JayT106)
-- [statesync] [\#6378](https://github.com/tendermint/tendermint/pull/6378) Retry requests for snapshots and add a minimum discovery time (5s) for new snapshots.
-- [node/state] [\#6370](https://github.com/tendermint/tendermint/pull/6370) graceful shutdown in the consensus reactor (@JayT106)
-- [crypto/merkle] [\#6443](https://github.com/tendermint/tendermint/pull/6443) Improve HashAlternatives performance (@cuonglm)
-- [crypto/merkle] [\#6513](https://github.com/tendermint/tendermint/pull/6513) Optimize HashAlternatives (@marbar3778)
-- [p2p/pex] [\#6509](https://github.com/tendermint/tendermint/pull/6509) Improve addrBook.hash performance (@cuonglm)
-- [consensus/metrics] [\#6549](https://github.com/tendermint/tendermint/pull/6549) Change block_size gauge to a histogram for better observability over time (@marbar3778)
-- [statesync] [\#6587](https://github.com/tendermint/tendermint/pull/6587) Increase chunk priority and re-request chunks that don't arrive (@cmwaters)
-- [state/privval] [\#6578](https://github.com/tendermint/tendermint/pull/6578) No GetPubKey retry beyond the proposal/voting window (@JayT106)
-- [rpc] [\#6615](https://github.com/tendermint/tendermint/pull/6615) Add TotalGasUsed to block_results response (@crypto-facs)
-- [cmd/tendermint/commands] [\#6623](https://github.com/tendermint/tendermint/pull/6623) replace `$HOME/.some/test/dir` with `t.TempDir` (@tanyabouman)
-- [statesync] \6807 Implement P2P state provider as an alternative to RPC (@cmwaters)
-
-## 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
-
-*September 6, 2021*
-
-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
-
-*August 17, 2021*
-
-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/pull/6494) `TMCoreSemVer` is not required to be set as a ldflag any longer.
-
-### IMPROVEMENTS
-
-- [statesync] [\#6566](https://github.com/tendermint/tendermint/pull/6566) Allow state sync fetchers and request timeout to be configurable. (@alexanderbez)
-- [statesync] [\#6378](https://github.com/tendermint/tendermint/pull/6378) Retry requests for snapshots and add a minimum discovery time (5s) for new snapshots. (@tychoish)
-- [statesync] [\#6582](https://github.com/tendermint/tendermint/pull/6582) Increase chunk priority and add multiple retry chunk requests (@cmwaters)
-
-### BUG FIXES
-
-- [evidence] [\#6375](https://github.com/tendermint/tendermint/pull/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)
@@ -263,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.
 
@@ -271,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
@@ -293,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)
@@ -330,13 +88,15 @@ 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 release tooling problems._
 
@@ -344,29 +104,33 @@ _Tendermint Core v0.34.5 and v0.34.6 have been recalled due to release tooling p
 
 *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
 
@@ -381,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
@@ -404,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
@@ -432,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
@@ -458,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)
@@ -524,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)
@@ -562,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)
@@ -672,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)
@@ -687,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
@@ -746,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
@@ -832,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)
@@ -844,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
@@ -894,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)
@@ -912,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
@@ -1140,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)
@@ -1151,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)
@@ -1172,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:
 
@@ -1211,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
@@ -1237,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
@@ -1252,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
@@ -1262,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
@@ -1297,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)
@@ -1317,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
@@ -1356,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
@@ -1401,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
@@ -1501,6 +1322,8 @@ 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:
 
@@ -1521,6 +1344,8 @@ 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:
 
@@ -1548,6 +1373,8 @@ 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:
 
@@ -1564,6 +1391,8 @@ 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:
 
@@ -1859,6 +1688,8 @@ 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:
 
@@ -1990,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:
 
@@ -2079,6 +1910,8 @@ 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
@@ -2118,6 +1951,8 @@ 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:
 
@@ -2166,6 +2001,8 @@ 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
@@ -2294,6 +2131,8 @@ 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
@@ -2356,6 +2195,8 @@ 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:
 
@@ -2395,6 +2236,8 @@ 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:
 
@@ -2439,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)
@@ -2456,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
@@ -2483,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
@@ -2629,6 +2476,8 @@ 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/develop/docs/architecture/adr-012-peer-transport.md).
 
+Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermint).
+
 BREAKING CHANGES:
 
 * CLI/RPC/Config

CHANGELOG_PENDING.md

@@ -1,53 +1,104 @@
 # Unreleased Changes
 
-Friendly reminder: We have a [bug bounty program](https://hackerone.com/cosmos).
-
 ## vX.X
 
-Month, DD, YYYY
-
 Special thanks to external contributors on this release:
 
+Friendly reminder: We have a [bug bounty program](https://hackerone.com/tendermint).
+
 ### BREAKING CHANGES
 
 - CLI/RPC/Config
-
-  - [rpc] Remove the deprecated gRPC interface to the RPC service. (@creachadair)
-  - [blocksync] \#7159 Remove support for disabling blocksync in any circumstance. (@tychoish)
-  - [mempool] \#7171 Remove legacy mempool implementation. (@tychoish)
+  - [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
-
-  - [proto/tendermint] \#6976 Remove core protobuf files in favor of only housing them in the [tendermint/spec](https://github.com/tendermint/spec) repository.
+  - [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
 
-  - [p2p] \#7035 Remove legacy P2P routing implementation and associated configuration options. (@tychoish)
-  - [p2p] \#7265 Peer manager reduces peer score for each failed dial attempts for peers that have not successfully dialed. (@tychoish)
-
 - Go API
-
-  - [pubsub] \#7231 Remove unbuffered subscriptions and rework the Subscription interface. (@creachadair)
-  - [eventbus] \#7231 Move the EventBus type to the internal/eventbus package. (@creachadair)
-  - [blocksync] \#7046 Remove v2 implementation of the blocksync service and recactor, which was disabled in the previous release. (@tychoish)
-  - [p2p] \#7064 Remove WDRR queue implementation. (@tychoish)
-  - [config] \#7169 `WriteConfigFile` now returns an error. (@tychoish)
-  - [libs/service] \#7288 Remove SetLogger method on `service.Service` interface. (@tychoish)
-
+  - [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
 
-- [rpc] [\#7270](https://github.com/tendermint/tendermint/pull/7270) Add `header` and `header_by_hash` RPC Client queries. (@fedekunze)
-- [cli] [#7033](https://github.com/tendermint/tendermint/pull/7033) Add a `rollback` command to rollback to the previous tendermint state in the event of non-determinstic app hash or reverting an upgrade.
-- [mempool, rpc] \#7041  Add removeTx operation to the RPC layer. (@tychoish)
+- [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
-- [internal/protoio] \#7325 Optimized `MarshalDelimited` by inlining the common case and using a `sync.Pool` in the worst case. (@odeke-em)
 
-- [pubsub] \#7319 Performance improvements for the event query API (@creachadair)
+- [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
 
-- fix: assignment copies lock value in `BitArray.UnmarshalJSON()` (@lklimek)
+- [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

@@ -109,7 +109,7 @@ We use [Protocol Buffers](https://developers.google.com/protocol-buffers) along
 
 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`. This command uses the spec repo to get the necessary protobuf files for generating the go code. If you are modifying the proto files manually for changes in the core data structures, you will need to clone them into the go repo and comment out lines 22-37 of the file `./scripts/protocgen.sh`.
+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`.
 
 ### Visual Studio Code
 
@@ -227,6 +227,114 @@ Fixes #nnnn
 
 Each PR should have one commit once it lands on `master`; this can be accomplished by using the "squash and merge" button on Github. Be sure to edit your commit message, though!
 
+### Release Procedure
+
+#### 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):
+   - Copy `CHANGELOG_PENDING.md` to top of `CHANGELOG.md`; if this release
+      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
+     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`
+   - Add any release notes you would like to be added to the body of the release to `release_notes.md`.
+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.
+6. Delete any RC branches and tags for this release (if applicable)
+
+#### Minor Release (Point Releases)
+
+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).
+
+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. 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. 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 backport branch into master.
+
+#### Release Candidates
+
+Before creating an official release, especially a major release, we may want to create a
+release candidate (RC) for our friends and partners to test out. We use git tags to
+create RCs, and we build them off of RC branches. RC branches typically have names formatted
+like `RCX/vX.X.X` (or, concretely, `RC0/v0.34.0`), while the tags themselves follow
+the "standard" release naming conventions, with `-rcX` at the end (`vX.X.X-rcX`).
+
+(Note that branches and tags _cannot_ have the same names, so it's important that these branches
+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:
+   `git checkout -b RC1/v0.34.0; git push origin RC1/v0.34.0`
+
 ## Testing
 
 ### Unit tests

DOCKER/Dockerfile

@@ -1,5 +1,5 @@
 # stage 1 Generate Tendermint Binary
-FROM golang:1.16-alpine as builder
+FROM golang:1.15-alpine as builder
 RUN apk update && \
     apk upgrade && \
     apk --no-cache add make

DOCKER/Dockerfile.build_c-amazonlinux

@@ -9,7 +9,7 @@ RUN wget http://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm &
 RUN yum -y groupinstall "Development Tools"
 RUN yum -y install leveldb-devel which
 
-ENV GOVERSION=1.16.5
+ENV GOVERSION=1.12.9
 
 RUN cd /tmp && \
     wget https://dl.google.com/go/go${GOVERSION}.linux-amd64.tar.gz && \

Makefile

@@ -1,5 +1,6 @@
 #!/usr/bin/make -f
 
+PACKAGES=$(shell go list ./...)
 BUILDDIR ?= $(CURDIR)/build
 
 BUILD_TAGS?=tendermint
@@ -11,10 +12,10 @@ else
 VERSION := $(shell git describe)
 endif
 
-LD_FLAGS = -X github.com/tendermint/tendermint/version.TMVersion=$(VERSION)
+LD_FLAGS = -X github.com/tendermint/tendermint/version.TMCoreSemVer=$(VERSION)
 BUILD_FLAGS = -mod=readonly -ldflags "$(LD_FLAGS)"
-BUILD_IMAGE := ghcr.io/tendermint/docker-build-proto
-DOCKER_PROTO_BUILDER := docker run -v $(shell pwd):/workspace --workdir /workspace $(BUILD_IMAGE)
+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
@@ -78,17 +79,32 @@ $(BUILDDIR)/:
 ###                                Protobuf                                 ###
 ###############################################################################
 
+proto-all: proto-gen proto-lint proto-check-breaking
+.PHONY: proto-all
+
 proto-gen:
 	@docker pull -q tendermintdev/docker-build-proto
 	@echo "Generating Protobuf files"
-	@$(DOCKER_PROTO_BUILDER) sh ./scripts/protocgen.sh
+	@docker run -v $(shell pwd):/workspace --workdir /workspace tendermintdev/docker-build-proto sh ./scripts/protocgen.sh
 .PHONY: proto-gen
 
+proto-lint:
+	@$(DOCKER_BUF) check lint --error-format=json
+.PHONY: proto-lint
+
 proto-format:
 	@echo "Formatting Protobuf files"
-	@$(DOCKER_PROTO_BUILDER) find ./ -not -path "./third_party/*" -name *.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:
+	@$(DOCKER_BUF) check breaking --against-input .git#branch=master
+.PHONY: proto-check-breaking
+
+proto-check-breaking-ci:
+	@$(DOCKER_BUF) check breaking --against-input $(HTTPS_GIT)#branch=master
+.PHONY: proto-check-breaking-ci
+
 ###############################################################################
 ###                              Build ABCI                                 ###
 ###############################################################################
@@ -102,7 +118,7 @@ install_abci:
 .PHONY: install_abci
 
 ###############################################################################
-###				Privval Server                              ###
+###                           	Privval Server                              ###
 ###############################################################################
 
 build_privval_server:
@@ -115,11 +131,11 @@ generate_test_cert:
 	# 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"
+	@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"
+	@certstrap sign client --CA "root CA" 
 .PHONY: generate_test_cert
 
 ###############################################################################
@@ -186,7 +202,7 @@ format:
 
 lint:
 	@echo "--> Running linter"
-	go run github.com/golangci/golangci-lint/cmd/golangci-lint run
+	@golangci-lint run
 .PHONY: lint
 
 DESTINATION = ./index.html.md
@@ -198,7 +214,7 @@ DESTINATION = ./index.html.md
 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 ; \
@@ -211,19 +227,10 @@ build-docs:
 
 build-docker: build-linux
 	cp $(BUILDDIR)/tendermint DOCKER/tendermint
-	docker build --label=tendermint --tag="tendermint/tendermint" -f DOCKER/Dockerfile .
+	docker build --label=tendermint --tag="tendermint/tendermint" DOCKER
 	rm -rf DOCKER/tendermint
 .PHONY: build-docker
 
-
-###############################################################################
-###                                Mocks                                    ###
-###############################################################################
-
-mockery:
-	go generate -run="./scripts/mockery_generate.sh" ./...
-.PHONY: mockery
-
 ###############################################################################
 ###                       Local testnet using docker                        ###
 ###############################################################################
@@ -287,23 +294,3 @@ build-reproducible:
 		--name latest-build cosmossdk/rbuilder:latest
 	docker cp -a latest-build:/home/builder/artifacts/ $(CURDIR)/
 .PHONY: build-reproducible
-
-# Implements test splitting and running. This is pulled directly from
-# the github action workflows for better local reproducibility.
-
-GO_TEST_FILES != find $(CURDIR) -name "*_test.go"
-
-# default to four splits by default
-NUM_SPLIT ?= 4
-
-$(BUILDDIR):
-	mkdir -p $@
-
-# the format statement filters out all packages that don't have tests.
-$(BUILDDIR)/packages.txt:$(GO_TEST_FILES) $(BUILDDIR)
-	go list -f "{{ if .TestGoFiles }}{{ .ImportPath }}{{ end }}" ./... | sort > $@
-
-split-test-packages:$(BUILDDIR)/packages.txt
-	split -d -n l/$(NUM_SPLIT) $< $<.
-test-group-%:split-test-packages
-	cat $(BUILDDIR)/packages.txt.$* | xargs go test -mod=readonly -timeout=8m -race -coverprofile=$(BUILDDIR)/$*.profile.out

README.md

@@ -8,8 +8,8 @@ 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.16-blue.svg)](https://github.com/moovweb/gvm)
-[![Discord chat](https://img.shields.io/discord/669268347736686612.svg)](https://discord.gg/cosmosnetwork)
+[![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/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)
@@ -18,7 +18,8 @@ Or [Blockchain](<https://en.wikipedia.org/wiki/Blockchain_(database)>), for shor
 |--------|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------|
 | 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 a Byzantine Fault Tolerant (BFT) middleware that takes a state transition machine - written in any programming language - and securely replicates it on many machines.
+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.
 
 For protocol details, see [the specification](https://github.com/tendermint/spec).
 
@@ -29,18 +30,18 @@ see our recent paper, "[The latest gossip on BFT consensus](https://arxiv.org/ab
 
 Please do not depend on master as your production branch. Use [releases](https://github.com/tendermint/tendermint/releases) instead.
 
-Tendermint has been in the production of private and public environments, most notably the blockchains of the Cosmos Network. we haven't released v1.0 yet since we are making breaking changes to the protocol and the APIs.
+Tendermint is being used in production in both private and public environments,
+most notably the blockchains of the [Cosmos Network](https://cosmos.network/).
+However, we are still making breaking changes to the protocol and the APIs and have not yet released v1.0.
 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/cosmosnetwork).
-
-More on how releases are conducted can be found [here](./RELEASES.md).
+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/cosmos).
+program](https://hackerone.com/tendermint). 
 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
@@ -50,7 +51,7 @@ to notify you of vulnerabilities and fixes in Tendermint Core. You can subscribe
 
 | Requirement | Notes            |
 |-------------|------------------|
-| Go version  | Go1.17 or higher |
+| Go version  | Go1.15 or higher |
 
 ## Documentation
 
@@ -63,8 +64,8 @@ See the [install instructions](/docs/introduction/install.md).
 ### Quick Start
 
 - [Single node](/docs/introduction/quick-start.md)
-- [Local cluster using docker-compose](/docs/tools/docker-compose.md)
-- [Remote cluster using Terraform and Ansible](/docs/tools/terraform-and-ansible.md)
+- [Local cluster using docker-compose](/docs/networks/docker-compose.md)
+- [Remote cluster using Terraform and Ansible](/docs/networks/terraform-and-ansible.md)
 - [Join the Cosmos testnet](https://cosmos.network/testnet)
 
 ## Contributing
@@ -73,7 +74,7 @@ Please abide by the [Code of Conduct](CODE_OF_CONDUCT.md) in all interactions.
 
 Before contributing to the project, please take a look at the [contributing guidelines](CONTRIBUTING.md)
 and the [style guide](STYLE_GUIDE.md). You may also find it helpful to read the
-[specifications](https://github.com/tendermint/spec), watch the [Developer Sessions](/docs/DEV_SESSIONS.md),
+[specifications](https://github.com/tendermint/spec), watch the [Developer Sessions](/docs/DEV_SESSIONS.md), 
 and familiarize yourself with our
 [Architectural Decision Records](https://github.com/tendermint/tendermint/tree/master/docs/architecture).
 
@@ -84,12 +85,32 @@ and familiarize yourself with our
 Tendermint uses [Semantic Versioning](http://semver.org/) to determine when and how the version changes.
 According to SemVer, anything in the public API can change at any time before version 1.0.0
 
-To provide some stability to users of 0.X.X versions of Tendermint, the MINOR version is used
-to signal breaking changes across Tendermint's API. This API includes all
-publicly exposed types, functions, and methods in non-internal Go packages as well as
-the types and methods accessible via the Tendermint RPC interface.
+To provide some stability to Tendermint users in these 0.X.X days, the MINOR version is used
+to signal breaking changes across a subset of the total public API. This subset includes all
+interfaces exposed to other processes (cli, rpc, p2p, etc.), but does not
+include the Go APIs.
 
-Breaking changes to these public APIs will be documented in the CHANGELOG.
+That said, breaking changes in the following packages will be documented in the
+CHANGELOG even if they don't lead to MINOR version bumps:
+
+- crypto
+- config
+- libs
+    - bits
+    - bytes
+    - json
+    - log
+    - math
+    - net
+    - os
+    - protoio
+    - rand
+    - sync
+    - strings
+    - service
+- node
+- rpc/client
+- types
 
 ### Upgrades
 
@@ -97,7 +118,7 @@ In an effort to avoid accumulating technical debt prior to 1.0.0,
 we do not guarantee that breaking changes (ie. bumps in the MINOR version)
 will work with existing Tendermint blockchains. In these cases you will
 have to start a new blockchain, or write something custom to get the old
-data into the new chain. However, any bump in the PATCH version should be
+data into the new chain. However, any bump in the PATCH version should be 
 compatible with existing blockchain histories.
 
 
@@ -114,8 +135,6 @@ in [UPGRADING.md](./UPGRADING.md).
 
 ### Tendermint Core
 
-We keep a public up-to-date version of our roadmap [here](./docs/roadmap/roadmap.md)
-
 For details about the blockchain data structures and the p2p protocols, see the
 [Tendermint specification](https://docs.tendermint.com/master/spec/).
 
@@ -148,4 +167,4 @@ If you'd like to work full-time on Tendermint Core, [we're hiring](https://inter
 
 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).
+ that also maintains [tendermint.com](https://tendermint.com).

RELEASES.md

@@ -1,180 +0,0 @@
-# Releases
-
-Tendermint uses [semantic versioning](https://semver.org/) with each release following
-a `vX.Y.Z` format. The `master` branch is used for active development and thus it's
-advisable not to build against it.
-
-The latest changes are always initially merged into `master`.
-Releases are specified using tags and are built from long-lived "backport" branches
-that are cut from `master` when the release process begins.
-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). Tendermint only
-maintains the last two releases at a time (the oldest release is predominantly
-just security patches).
-
-## Backporting
-
-As non-breaking changes land on `master`, they should also be backported
-to these backport branches.
-
-We use Mergify's [backport feature](https://mergify.io/features/backports) to automatically backport
-to the needed branch. There should be a label for any backport branch that you'll be targeting.
-To notify the bot to backport a pull request, mark the pull request with the label corresponding
-to the correct backport branch. For example, to backport to v0.35.x, add the label `S:backport-to-v0.35.x`.
-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.
-
-### Creating a backport branch
-
-If this is the first release candidate for a major release, you get to have the
-honor of creating the backport branch!
-
-Note that, after creating the backport branch, you'll also need to update the
-tags on `master` so that `go mod` is able to order the branches correctly. You
-should tag `master` with a "dev" tag that is "greater than" the backport
-branches tags. See [#6072](https://github.com/tendermint/tendermint/pull/6072)
-for more context.
-
-In the following example, we'll assume that we're making a backport branch for
-the 0.35.x line.
-
-1. Start on `master`
-2. Create and push the backport branch:
-   ```sh
-   git checkout -b v0.35.x
-   git push origin v0.35.x
-   ```
-
-After doing these steps, go back to `master` and do the following:
-
-1. Tag `master` as the dev branch for the _next_ major release and push it back up.
-   For example:
-   ```sh
-   git tag -a v0.36.0-dev -m "Development base for Tendermint v0.36."
-   git push origin v0.36.0-dev
-   ```
-
-2. Create a new workflow to run e2e nightlies for the new backport branch.
-   (See [e2e-nightly-master.yml][e2e] for an example.)
-
-3. Add a new section to the Mergify config (`.github/mergify.yml`) to enable the
-   backport bot to work on this branch, and add a corresponding `S:backport-to-v0.35.x`
-   [label](https://github.com/tendermint/tendermint/labels) so the bot can be triggered.
-
-4. Add a new section to the Dependabot config (`.github/dependabot.yml`) to
-   enable automatic update of Go dependencies on this branch. Copy and edit one
-   of the existing branch configurations to set the correct `target-branch`.
-
-[e2e]: https://github.com/tendermint/tendermint/blob/master/.github/workflows/e2e-nightly-master.yml
-
-## Release candidates
-
-Before creating an official release, especially a major release, we may want to create a
-release candidate (RC) for our friends and partners to test out. We use git tags to
-create RCs, and we build them off of backport branches.
-
-Tags for RCs should follow the "standard" release naming conventions, with `-rcX` at the end
-(for example, `v0.35.0-rc0`).
-
-(Note that branches and tags _cannot_ have the same names, so it's important that these branches
-have distinct names from the tags/release names.)
-
-If this is the first RC for a major release, you'll have to make a new backport branch (see above).
-Otherwise:
-
-1. Start from the backport branch (e.g. `v0.35.x`).
-2. Run the integration tests and the e2e nightlies
-   (which can be triggered from the Github UI;
-   e.g., https://github.com/tendermint/tendermint/actions/workflows/e2e-nightly-34x.yml).
-3. Prepare the changelog:
-   - Move the changes included in `CHANGELOG_PENDING.md` into `CHANGELOG.md`. Each RC should have
-     it's own changelog section. These will be squashed when the final candidate is released.
-   - 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 TMVersionDefault version in  `version.go`
-   - Bump P2P and block protocol versions in  `version.go`, if necessary.
-     Check the changelog for breaking changes in these components.
-   - Bump ABCI protocol version in `version.go`, if necessary
-4. Open a PR with these changes against the backport branch.
-5. Once these changes have landed on the backport branch, be sure to pull them back down locally.
-6. Once you have the changes locally, create the new tag, specifying a name and a tag "message":
-   `git tag -a v0.35.0-rc0 -m "Release Candidate v0.35.0-rc0`
-7. Push the tag back up to origin:
-   `git push origin v0.35.0-rc0`
-   Now the tag should be available on the repo's releases page.
-8. Future RCs will continue to be built off of this branch.
-
-Note that this process should only be used for "true" RCs--
-release candidates that, if successful, will be the next release.
-For more experimental "RCs," create a new, short-lived branch and tag that instead.
-
-## Major release
-
-This major release process assumes that this release was preceded by release candidates.
-If there were no release candidates, begin by creating a backport branch, as described above.
-
-1. Start on the backport branch (e.g. `v0.35.x`)
-2. Run integration tests (`make test_integrations`) and the e2e nightlies.
-3. 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 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
-4. Open a PR with these changes against the backport branch.
-5. Once these changes are on the backport branch, push a tag with prepared release details.
-   This will trigger the actual release `v0.35.0`.
-   - `git tag -a v0.35.0 -m 'Release v0.35.0'`
-   - `git push origin v0.35.0`
-6. Make sure that `master` is updated with the latest `CHANGELOG.md`, `CHANGELOG_PENDING.md`, and `UPGRADING.md`.
-7. Add the release to the documentation site generator config (see
-   [DOCS_README.md](./docs/DOCS_README.md) for more details). In summary:
-   - Start on branch `master`.
-   - Add a new line at the bottom of [`docs/versions`](./docs/versions) to
-     ensure the newest release is the default for the landing page.
-   - Add a new entry to `themeConfig.versions` in
-     [`docs/.vuepress/config.js`](./docs/.vuepress/config.js) to include the
-	 release in the dropdown versions menu.
-   - Commit these changes to `master` and backport them into the backport
-     branch for this release.
-
-## Minor release (point releases)
-
-Minor releases are done differently from major releases: They are built off of
-long-lived backport branches, rather than from master.  As non-breaking changes
-land on `master`, they should also be backported into these backport branches.
-
-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 v0.35.x`
-2. Run integration tests (`make test_integrations`) and the nightlies.
-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 TMDefaultVersion in `version.go`
-   - 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.)
-4. Open a PR with these changes that will land them back on `v0.35.x`
-5. Once this change has landed on the backport branch, make sure to pull it locally, then push a tag.
-   - `git tag -a v0.35.1 -m 'Release v0.35.1'`
-   - `git push origin v0.35.1`
-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 backport branch into master.

SECURITY.md

@@ -4,7 +4,7 @@
 
 As part of our [Coordinated Vulnerability Disclosure
 Policy](https://tendermint.com/security), we operate a [bug
-bounty](https://hackerone.com/cosmos).
+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
@@ -86,7 +86,7 @@ If you are running older versions of Tendermint Core, we encourage you to upgrad
 
 ## Scope
 
-The full scope of our bug bounty program is outlined on our [Hacker One program page](https://hackerone.com/cosmos). Please also note that, in the interest of the safety of our users and staff, a few things are explicitly excluded from 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

UPGRADING.md

@@ -2,75 +2,34 @@
 
 This guide provides instructions for upgrading to specific versions of Tendermint Core.
 
-## v0.35
+## 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.
-* When mempool `v1` is enabled, transactions broadcasted via `sync` mode may return a successful
-  response with a transaction hash indicating that the transaction was successfully inserted into
-  the mempool. While this is true for `v0`, the `v1` mempool reactor may at a later point in time
-  evict or even drop this transaction after a hash has been returned. Thus, the user or client must
-  query for that transaction to check if it is still in the mempool.
 
 ### Config Changes
 
-* The configuration file field `[fastsync]` has been renamed to `[blocksync]`.
-
-* The top level configuration file field `fast-sync` has moved under the new `[blocksync]`
-  field as `blocksync.enable`.
-
-* `blocksync.version = "v1"` and `blocksync.version = "v2"` (previously `fastsync`)
-  are no longer supported. Please use `v0` instead. During the v0.35 release cycle, `v0` was
-  determined to suit the existing needs and the cost of maintaining the `v1` and `v2` modules
-  was determined to be greater than necessary.
-
+* `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.
-
-* configuration values starting with `priv-validator-` have moved to the new
-  `priv-validator` section, without the `priv-validator-` prefix.
-
-* The fast sync process as well as the blockchain package and service has all
-  been renamed to block sync
-
-### Database Key Format Changes
-
-The format of all tendermint on-disk database keys changes in
-0.35. Upgrading nodes must either re-sync all data or run a migration
-script provided in this release. The script located in
-`github.com/tendermint/tendermint/scripts/keymigrate/migrate.go`
-provides the function `Migrate(context.Context, db.DB)` which you can
-operationalize as makes sense for your deployment.
-
-For ease of use the `tendermint` command includes a CLI version of the
-migration script, which you can invoke, as in:
-
-	tendermint key-migrate
-
-This reads the configuration file as normal and allows the
-`--db-backend` and `--db-dir` flags to change database operations as
-needed.
-
-The migration operation is idempotent and can be run more than once,
-if needed.
+  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]`
 
-* The `--fast-sync` command line option has been renamed to `--blocksync.enable`
-
 * 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
@@ -82,132 +41,13 @@ if needed.
 
 * 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
-
-### API Changes
-
-The p2p layer was reimplemented as part of the 0.35 release cycle and
-all reactors were refactored to accomodate the change. As part of that work these
-implementations moved into the `internal` package and are no longer
-considered part of the public Go API of tendermint. These packages
-are:
-
-- `p2p`
-- `mempool`
-- `consensus`
-- `statesync`
-- `blockchain`
-- `evidence`
-
-Accordingly, the `node` package changed to reduce access to
-tendermint internals: applications that use tendermint as a library
-will need to change to accommodate these changes. Most notably:
-
-- The `Node` type has become internal, and all constructors return a
-  `service.Service` implementation.
-
-- The `node.DefaultNewNode` and `node.NewNode` constructors are no
-  longer exported and have been replaced with `node.New` and
-  `node.NewDefault` which provide more functional interfaces.
-
-To access any of the functionality previously available via the
-`node.Node` type, use the `*local.Local` "RPC" client, that exposes
-the full RPC interface provided as direct function calls. Import the
-`github.com/tendermint/tendermint/rpc/client/local` package and pass
-the node service as in the following: 
-
-```go
-    node := node.NewDefault() //construct the node object
-    // start and set up the node service 
-
-    client := local.New(node.(local.NodeService))
-    // use client object to interact with the node
-```
-
-### gRPC Support
-
-Mark gRPC in the RPC layer as deprecated and to be removed in 0.36.
-
-### Peer Management Interface
-
-When running with the new P2P Layer, the methods `UnsafeDialSeeds` and
-`UnsafeDialPeers` RPC methods will always return an error. They are
-deprecated and will be removed in 0.36 when the legacy peer stack is
-removed.
-
-Additionally the format of the Peer list returned in the `NetInfo`
-method changes in this release to accommodate the different way that
-the new stack tracks data about peers. This change affects users of
-both stacks.
-
-### Using the updated p2p library
-
-The P2P library was reimplemented in this release. The new implementation is
-enabled by default in this version of Tendermint. The legacy implementation is still
-included in this version of Tendermint as a backstop to work around unforeseen
-production issues. The new and legacy version are interoperable. If necessary, 
-you can enable the legacy implementation in the server configuration file.
-
-To make use of the legacy P2P implemementation add or update the following field of 
-your server's configuration file under the `[p2p]` section:
-
-```toml
-[p2p]
-...
-use-legacy = true
-...
-```
-
-If you need to do this, please consider filing an issue in the Tendermint repository
-to let us know why. We plan to remove the legacy P2P code in the next (v0.36) release.
-
-#### New p2p queue types
-
-The new p2p implementation enables selection of the queue type to be used for
-passing messages between peers.
-
-The following values may be used when selecting which queue type to use:
-
-* `fifo`: (**default**) An unbuffered and lossless queue that passes messages through
-in the order in which they were received.
-
-* `priority`: A priority queue of messages.
-
-* `wdrr`: A queue implementing the Weighted Deficit Round Robin algorithm. A 
-weighted deficit round robin queue is created per peer. Each queue contains a 
-separate 'flow' for each of the channels of communication that exist between any two
-peers. Tendermint maintains a channel per message type between peers. Each WDRR
-queue maintains a shared buffered with a fixed capacity through which messages on different
-flows are passed.
-For more information on WDRR scheduling, see: https://en.wikipedia.org/wiki/Deficit_round_robin
-
-To select a queue type, add or update the following field under the `[p2p]`
-section of your server's configuration file.
-
-```toml
-[p2p]
-...
-queue-type = wdrr
-...
-```
-
-
-### Support for Custom Reactor and Mempool Implementations
-
-The changes to p2p layer removed existing support for custom
-reactors. Based on our understanding of how this functionality was
-used, the introduction of the prioritized mempool covers nearly all of
-the use cases for custom reactors. If you are currently running custom
-reactors and mempools and are having trouble seeing the migration path
-for your project please feel free to reach out to the Tendermint Core
-development team directly.
-
 ## 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.16 or higher.
+Note also that Tendermint 0.34 also requires Go 1.15 or higher.
 
 ### ABCI Changes
 
@@ -354,8 +194,8 @@ Other user-relevant changes include:
 
 * The old `lite` package was removed; the new light client uses the `light` package.
 * The `Verifier` was broken up into two pieces:
-	* Core verification logic (pure `VerifyX` functions)
-	* `Client` object, which represents the complete light client
+    * 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.
@@ -487,12 +327,12 @@ Evidence Params has been changed to include duration.
 ### Go API
 
 * `libs/common` has been removed in favor of specific pkgs.
-	* `async`
-	* `service`
-	* `rand`
-	* `net`
-	* `strings`
-	* `cmap`
+    * `async`
+    * `service`
+    * `rand`
+    * `net`
+    * `strings`
+    * `cmap`
 * removal of `errors` pkg
 
 ### RPC Changes
@@ -561,9 +401,9 @@ Prior to the update, suppose your `ResponseDeliverTx` look like:
 ```go
 abci.ResponseDeliverTx{
   Tags: []kv.Pair{
-	{Key: []byte("sender"), Value: []byte("foo")},
-	{Key: []byte("recipient"), Value: []byte("bar")},
-	{Key: []byte("amount"), Value: []byte("35")},
+    {Key: []byte("sender"), Value: []byte("foo")},
+    {Key: []byte("recipient"), Value: []byte("bar")},
+    {Key: []byte("amount"), Value: []byte("35")},
   }
 }
 ```
@@ -582,14 +422,14 @@ the following `Events`:
 ```go
 abci.ResponseDeliverTx{
   Events: []abci.Event{
-	{
-	  Type: "transfer",
-	  Attributes: kv.Pairs{
-		{Key: []byte("sender"), Value: []byte("foo")},
-		{Key: []byte("recipient"), Value: []byte("bar")},
-		{Key: []byte("amount"), Value: []byte("35")},
-	  },
-	}
+    {
+      Type: "transfer",
+      Attributes: kv.Pairs{
+        {Key: []byte("sender"), Value: []byte("foo")},
+        {Key: []byte("recipient"), Value: []byte("bar")},
+        {Key: []byte("amount"), Value: []byte("35")},
+      },
+    }
 }
 ```
 
@@ -637,9 +477,9 @@ In this case, the WS client will receive an error with description:
   "jsonrpc": "2.0",
   "id": "{ID}#event",
   "error": {
-	"code": -32000,
-	"msg": "Server error",
-	"data": "subscription was canceled (reason: client is not pulling messages fast enough)" // or "subscription was canceled (reason: Tendermint exited)"
+    "code": -32000,
+    "msg": "Server error",
+    "data": "subscription was canceled (reason: client is not pulling messages fast enough)" // or "subscription was canceled (reason: Tendermint exited)"
   }
 }
 
@@ -845,9 +685,9 @@ just the `Data` field set:
 
 ```go
 []ProofOp{
-	ProofOp{
-		Data: <proof bytes>,
-	}
+    ProofOp{
+        Data: <proof bytes>,
+    }
 }
 ```
 

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](https://github.com/tendermint/spec/blob/master/proto/tendermint/abci/types.proto)
+- [A protobuf file](../proto/tendermint/abci/types.proto)
 - [A Go interface](./types/application.go)
 
 ## Protocol Buffers

abci/client/client.go

@@ -1,4 +1,4 @@
-package abciclient
+package abcicli
 
 import (
 	"context"
@@ -6,8 +6,8 @@ import (
 	"sync"
 
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
+	tmsync "github.com/tendermint/tendermint/libs/sync"
 )
 
 const (
@@ -15,7 +15,7 @@ const (
 	echoRetryIntervalSeconds = 1
 )
 
-//go:generate ../../scripts/mockery_generate.sh Client
+//go:generate mockery --case underscore --name Client
 
 // Client defines an interface for an ABCI client.
 //
@@ -68,12 +68,12 @@ type Client interface {
 
 // NewClient returns a new ABCI client of the specified transport type.
 // It returns an error if the transport is not "socket" or "grpc"
-func NewClient(logger log.Logger, addr, transport string, mustConnect bool) (client Client, err error) {
+func NewClient(addr, transport string, mustConnect bool) (client Client, err error) {
 	switch transport {
 	case "socket":
-		client = NewSocketClient(logger, addr, mustConnect)
+		client = NewSocketClient(addr, mustConnect)
 	case "grpc":
-		client = NewGRPCClient(logger, addr, mustConnect)
+		client = NewGRPCClient(addr, mustConnect)
 	default:
 		err = fmt.Errorf("unknown abci transport %s", transport)
 	}
@@ -87,7 +87,7 @@ type ReqRes struct {
 	*sync.WaitGroup
 	*types.Response // Not set atomically, so be sure to use WaitGroup.
 
-	mtx  sync.Mutex
+	mtx  tmsync.RWMutex
 	done bool                  // Gets set to true once *after* WaitGroup.Done().
 	cb   func(*types.Response) // A single callback that may be set.
 }
@@ -137,16 +137,16 @@ func (r *ReqRes) InvokeCallback() {
 //
 // ref: https://github.com/tendermint/tendermint/issues/5439
 func (r *ReqRes) GetCallback() func(*types.Response) {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
+	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()
 	r.done = true
-	r.mtx.Unlock()
 }
 
 func waitGroup1() (wg *sync.WaitGroup) {

abci/client/creators.go

@@ -1,36 +0,0 @@
-package abciclient
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
-)
-
-// Creator creates new ABCI clients.
-type Creator func(log.Logger) (Client, error)
-
-// NewLocalCreator returns a Creator for the given app,
-// which will be running locally.
-func NewLocalCreator(app types.Application) Creator {
-	mtx := new(sync.Mutex)
-
-	return func(_ log.Logger) (Client, error) {
-		return NewLocalClient(mtx, app), nil
-	}
-}
-
-// NewRemoteCreator returns a Creator for the given address (e.g.
-// "192.168.0.1") and transport (e.g. "tcp"). Set mustConnect to true if you
-// want the client to connect before reporting success.
-func NewRemoteCreator(logger log.Logger, addr, transport string, mustConnect bool) Creator {
-	return func(log.Logger) (Client, error) {
-		remoteApp, err := NewClient(logger, addr, transport, mustConnect)
-		if err != nil {
-			return nil, fmt.Errorf("failed to connect to proxy: %w", err)
-		}
-
-		return remoteApp, nil
-	}
-}

abci/client/doc.go

@@ -1,4 +1,4 @@
-// Package abciclient provides an ABCI implementation in Go.
+// Package abcicli provides an ABCI implementation in Go.
 //
 // There are 3 clients available:
 //		1. socket (unix or TCP)
@@ -26,4 +26,4 @@
 //
 // sync: waits for all Async calls to complete (essentially what Flush does in
 // the socket client) and calls Sync method.
-package abciclient
+package abcicli

abci/client/grpc_client.go

@@ -1,4 +1,4 @@
-package abciclient
+package abcicli
 
 import (
 	"context"
@@ -10,23 +10,21 @@ import (
 	"google.golang.org/grpc"
 
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 	"github.com/tendermint/tendermint/libs/service"
+	tmsync "github.com/tendermint/tendermint/libs/sync"
 )
 
 // A gRPC client.
 type grpcClient struct {
 	service.BaseService
-	logger log.Logger
-
 	mustConnect bool
 
 	client   types.ABCIApplicationClient
 	conn     *grpc.ClientConn
 	chReqRes chan *ReqRes // dispatches "async" responses to callbacks *in order*, needed by mempool
 
-	mtx   sync.Mutex
+	mtx   tmsync.RWMutex
 	addr  string
 	err   error
 	resCb func(*types.Request, *types.Response) // listens to all callbacks
@@ -44,9 +42,8 @@ var _ Client = (*grpcClient)(nil)
 // 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(logger log.Logger, addr string, mustConnect bool) Client {
+func NewGRPCClient(addr string, mustConnect bool) Client {
 	cli := &grpcClient{
-		logger:      logger,
 		addr:        addr,
 		mustConnect: mustConnect,
 		// Buffering the channel is needed to make calls appear asynchronous,
@@ -57,7 +54,7 @@ func NewGRPCClient(logger log.Logger, addr string, mustConnect bool) Client {
 		// gRPC calls while processing a slow callback at the channel head.
 		chReqRes: make(chan *ReqRes, 64),
 	}
-	cli.BaseService = *service.NewBaseService(logger, "grpcClient", cli)
+	cli.BaseService = *service.NewBaseService(nil, "grpcClient", cli)
 	return cli
 }
 
@@ -65,7 +62,7 @@ func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
 	return tmnet.Connect(addr)
 }
 
-func (cli *grpcClient) OnStart(ctx context.Context) error {
+func (cli *grpcClient) OnStart() error {
 	// This processes asynchronous request/response messages and dispatches
 	// them to callbacks.
 	go func() {
@@ -87,19 +84,12 @@ func (cli *grpcClient) OnStart(ctx context.Context) error {
 				cb(reqres.Response)
 			}
 		}
-
-		for {
-			select {
-			case reqres := <-cli.chReqRes:
-				if reqres != nil {
-					callCb(reqres)
-				} else {
-					cli.logger.Error("Received nil reqres")
-				}
-			case <-ctx.Done():
-				return
+		for reqres := range cli.chReqRes {
+			if reqres != nil {
+				callCb(reqres)
+			} else {
+				cli.Logger.Error("Received nil reqres")
 			}
-
 		}
 	}()
 
@@ -110,12 +100,12 @@ RETRY_LOOP:
 			if cli.mustConnect {
 				return err
 			}
-			cli.logger.Error(fmt.Sprintf("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr), "err", err)
+			cli.Logger.Error(fmt.Sprintf("abci.grpcClient failed to connect to %v.  Retrying...\n", cli.addr), "err", err)
 			time.Sleep(time.Second * dialRetryIntervalSeconds)
 			continue RETRY_LOOP
 		}
 
-		cli.logger.Info("Dialed server. Waiting for echo.", "addr", cli.addr)
+		cli.Logger.Info("Dialed server. Waiting for echo.", "addr", cli.addr)
 		client := types.NewABCIApplicationClient(conn)
 		cli.conn = conn
 
@@ -125,7 +115,7 @@ RETRY_LOOP:
 			if err == nil {
 				break ENSURE_CONNECTED
 			}
-			cli.logger.Error("Echo failed", "err", err)
+			cli.Logger.Error("Echo failed", "err", err)
 			time.Sleep(time.Second * echoRetryIntervalSeconds)
 		}
 
@@ -152,15 +142,15 @@ func (cli *grpcClient) StopForError(err error) {
 	}
 	cli.mtx.Unlock()
 
-	cli.logger.Error(fmt.Sprintf("Stopping abci.grpcClient for error: %v", err.Error()))
+	cli.Logger.Error(fmt.Sprintf("Stopping abci.grpcClient for error: %v", err.Error()))
 	if err := cli.Stop(); err != nil {
-		cli.logger.Error("Error stopping abci.grpcClient", "err", err)
+		cli.Logger.Error("Error stopping abci.grpcClient", "err", err)
 	}
 }
 
 func (cli *grpcClient) Error() error {
-	cli.mtx.Lock()
-	defer cli.mtx.Unlock()
+	cli.mtx.RLock()
+	defer cli.mtx.RUnlock()
 	return cli.err
 }
 
@@ -168,8 +158,8 @@ 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()
 }
 
 //----------------------------------------

abci/client/local_client.go

@@ -1,11 +1,11 @@
-package abciclient
+package abcicli
 
 import (
 	"context"
-	"sync"
 
 	types "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/service"
+	tmsync "github.com/tendermint/tendermint/libs/sync"
 )
 
 // NOTE: use defer to unlock mutex because Application might panic (e.g., in
@@ -15,7 +15,7 @@ import (
 type localClient struct {
 	service.BaseService
 
-	mtx *sync.Mutex
+	mtx *tmsync.RWMutex
 	types.Application
 	Callback
 }
@@ -26,21 +26,20 @@ var _ Client = (*localClient)(nil)
 // methods of the given app.
 //
 // Both Async and Sync methods ignore the given context.Context parameter.
-func NewLocalClient(mtx *sync.Mutex, app types.Application) Client {
+func NewLocalClient(mtx *tmsync.RWMutex, app types.Application) Client {
 	if mtx == nil {
-		mtx = new(sync.Mutex)
+		mtx = &tmsync.RWMutex{}
 	}
+
 	cli := &localClient{
 		mtx:         mtx,
 		Application: app,
 	}
+
 	cli.BaseService = *service.NewBaseService(nil, "localClient", cli)
 	return cli
 }
 
-func (*localClient) OnStart(context.Context) error { return nil }
-func (*localClient) OnStop()                       {}
-
 func (app *localClient) SetResponseCallback(cb Callback) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
@@ -68,8 +67,8 @@ func (app *localClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, err
 }
 
 func (app *localClient) InfoAsync(ctx context.Context, req types.RequestInfo) (*ReqRes, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Info(req)
 	return app.callback(
@@ -101,8 +100,8 @@ func (app *localClient) CheckTxAsync(ctx context.Context, req types.RequestCheck
 }
 
 func (app *localClient) QueryAsync(ctx context.Context, req types.RequestQuery) (*ReqRes, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Query(req)
 	return app.callback(
@@ -216,8 +215,8 @@ func (app *localClient) EchoSync(ctx context.Context, msg string) (*types.Respon
 }
 
 func (app *localClient) InfoSync(ctx context.Context, req types.RequestInfo) (*types.ResponseInfo, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Info(req)
 	return &res, nil
@@ -250,8 +249,8 @@ func (app *localClient) QuerySync(
 	ctx context.Context,
 	req types.RequestQuery,
 ) (*types.ResponseQuery, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
+	app.mtx.RLock()
+	defer app.mtx.RUnlock()
 
 	res := app.Application.Query(req)
 	return &res, nil

abci/client/mocks/client.go

@@ -1,11 +1,13 @@
-// Code generated by mockery. DO NOT EDIT.
+// Code generated by mockery v2.5.1. DO NOT EDIT.
 
 package mocks
 
 import (
 	context "context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
+
+	log "github.com/tendermint/tendermint/libs/log"
 
 	mock "github.com/stretchr/testify/mock"
 
@@ -18,15 +20,15 @@ type Client struct {
 }
 
 // ApplySnapshotChunkAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) ApplySnapshotChunkAsync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*abciclient.ReqRes, error) {
+func (_m *Client) ApplySnapshotChunkAsync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -64,15 +66,15 @@ func (_m *Client) ApplySnapshotChunkSync(_a0 context.Context, _a1 types.RequestA
 }
 
 // BeginBlockAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) BeginBlockAsync(_a0 context.Context, _a1 types.RequestBeginBlock) (*abciclient.ReqRes, error) {
+func (_m *Client) BeginBlockAsync(_a0 context.Context, _a1 types.RequestBeginBlock) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -110,15 +112,15 @@ func (_m *Client) BeginBlockSync(_a0 context.Context, _a1 types.RequestBeginBloc
 }
 
 // CheckTxAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abciclient.ReqRes, error) {
+func (_m *Client) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -156,15 +158,15 @@ func (_m *Client) CheckTxSync(_a0 context.Context, _a1 types.RequestCheckTx) (*t
 }
 
 // CommitAsync provides a mock function with given fields: _a0
-func (_m *Client) CommitAsync(_a0 context.Context) (*abciclient.ReqRes, error) {
+func (_m *Client) CommitAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context) *abciclient.ReqRes); ok {
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -202,15 +204,15 @@ func (_m *Client) CommitSync(_a0 context.Context) (*types.ResponseCommit, error)
 }
 
 // DeliverTxAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abciclient.ReqRes, error) {
+func (_m *Client) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -248,15 +250,15 @@ func (_m *Client) DeliverTxSync(_a0 context.Context, _a1 types.RequestDeliverTx)
 }
 
 // EchoAsync provides a mock function with given fields: ctx, msg
-func (_m *Client) EchoAsync(ctx context.Context, msg string) (*abciclient.ReqRes, error) {
+func (_m *Client) EchoAsync(ctx context.Context, msg string) (*abcicli.ReqRes, error) {
 	ret := _m.Called(ctx, msg)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, string) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -294,15 +296,15 @@ func (_m *Client) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho
 }
 
 // EndBlockAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) EndBlockAsync(_a0 context.Context, _a1 types.RequestEndBlock) (*abciclient.ReqRes, error) {
+func (_m *Client) EndBlockAsync(_a0 context.Context, _a1 types.RequestEndBlock) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -354,15 +356,15 @@ func (_m *Client) Error() error {
 }
 
 // FlushAsync provides a mock function with given fields: _a0
-func (_m *Client) FlushAsync(_a0 context.Context) (*abciclient.ReqRes, error) {
+func (_m *Client) FlushAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context) *abciclient.ReqRes); ok {
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -391,15 +393,15 @@ func (_m *Client) FlushSync(_a0 context.Context) error {
 }
 
 // InfoAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) InfoAsync(_a0 context.Context, _a1 types.RequestInfo) (*abciclient.ReqRes, error) {
+func (_m *Client) InfoAsync(_a0 context.Context, _a1 types.RequestInfo) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *abciclient.ReqRes); ok {
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -437,15 +439,15 @@ func (_m *Client) InfoSync(_a0 context.Context, _a1 types.RequestInfo) (*types.R
 }
 
 // InitChainAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) InitChainAsync(_a0 context.Context, _a1 types.RequestInitChain) (*abciclient.ReqRes, error) {
+func (_m *Client) InitChainAsync(_a0 context.Context, _a1 types.RequestInitChain) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *abciclient.ReqRes); ok {
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -497,15 +499,15 @@ func (_m *Client) IsRunning() bool {
 }
 
 // ListSnapshotsAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) ListSnapshotsAsync(_a0 context.Context, _a1 types.RequestListSnapshots) (*abciclient.ReqRes, error) {
+func (_m *Client) ListSnapshotsAsync(_a0 context.Context, _a1 types.RequestListSnapshots) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -543,15 +545,15 @@ func (_m *Client) ListSnapshotsSync(_a0 context.Context, _a1 types.RequestListSn
 }
 
 // LoadSnapshotChunkAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) LoadSnapshotChunkAsync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*abciclient.ReqRes, error) {
+func (_m *Client) LoadSnapshotChunkAsync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -589,15 +591,15 @@ func (_m *Client) LoadSnapshotChunkSync(_a0 context.Context, _a1 types.RequestLo
 }
 
 // OfferSnapshotAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) OfferSnapshotAsync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*abciclient.ReqRes, error) {
+func (_m *Client) OfferSnapshotAsync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -634,16 +636,49 @@ func (_m *Client) OfferSnapshotSync(_a0 context.Context, _a1 types.RequestOfferS
 	return r0, r1
 }
 
+// OnReset provides a mock function with given fields:
+func (_m *Client) OnReset() 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
+}
+
+// OnStart provides a mock function with given fields:
+func (_m *Client) OnStart() 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
+}
+
+// OnStop provides a mock function with given fields:
+func (_m *Client) OnStop() {
+	_m.Called()
+}
+
 // QueryAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) QueryAsync(_a0 context.Context, _a1 types.RequestQuery) (*abciclient.ReqRes, error) {
+func (_m *Client) QueryAsync(_a0 context.Context, _a1 types.RequestQuery) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	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).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -680,18 +715,67 @@ func (_m *Client) QuerySync(_a0 context.Context, _a1 types.RequestQuery) (*types
 	return r0, r1
 }
 
-// SetResponseCallback provides a mock function with given fields: _a0
-func (_m *Client) SetResponseCallback(_a0 abciclient.Callback) {
+// Quit provides a mock function with given fields:
+func (_m *Client) Quit() <-chan struct{} {
+	ret := _m.Called()
+
+	var r0 <-chan struct{}
+	if rf, ok := ret.Get(0).(func() <-chan struct{}); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(<-chan struct{})
+		}
+	}
+
+	return r0
+}
+
+// Reset provides a mock function with given fields:
+func (_m *Client) Reset() 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
+}
+
+// SetLogger provides a mock function with given fields: _a0
+func (_m *Client) SetLogger(_a0 log.Logger) {
 	_m.Called(_a0)
 }
 
-// Start provides a mock function with given fields: _a0
-func (_m *Client) Start(_a0 context.Context) error {
-	ret := _m.Called(_a0)
+// SetResponseCallback provides a mock function with given fields: _a0
+func (_m *Client) SetResponseCallback(_a0 abcicli.Callback) {
+	_m.Called(_a0)
+}
+
+// Start provides a mock function with given fields:
+func (_m *Client) Start() error {
+	ret := _m.Called()
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context) error); ok {
-		r0 = rf(_a0)
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Stop provides a mock function with given fields:
+func (_m *Client) Stop() error {
+	ret := _m.Called()
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
 	} else {
 		r0 = ret.Error(0)
 	}
@@ -712,8 +796,3 @@ func (_m *Client) String() string {
 
 	return r0
 }
-
-// Wait provides a mock function with given fields:
-func (_m *Client) Wait() {
-	_m.Called()
-}

abci/client/socket_client.go

@@ -1,4 +1,4 @@
-package abciclient
+package abcicli
 
 import (
 	"bufio"
@@ -9,19 +9,21 @@ import (
 	"io"
 	"net"
 	"reflect"
-	"sync"
 	"time"
 
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 	"github.com/tendermint/tendermint/libs/service"
+	tmsync "github.com/tendermint/tendermint/libs/sync"
+	"github.com/tendermint/tendermint/libs/timer"
 )
 
 const (
 	// 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 {
@@ -33,15 +35,15 @@ type reqResWithContext struct {
 // general is not meant to be interfaced with concurrent callers.
 type socketClient struct {
 	service.BaseService
-	logger log.Logger
 
 	addr        string
 	mustConnect bool
 	conn        net.Conn
 
-	reqQueue chan *reqResWithContext
+	reqQueue   chan *reqResWithContext
+	flushTimer *timer.ThrottleTimer
 
-	mtx     sync.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.
@@ -52,22 +54,23 @@ var _ Client = (*socketClient)(nil)
 // NewSocketClient creates a new socket client, which connects to a given
 // address. If mustConnect is true, the client will return an error upon start
 // if it fails to connect.
-func NewSocketClient(logger log.Logger, addr string, mustConnect bool) Client {
+func NewSocketClient(addr string, mustConnect bool) Client {
 	cli := &socketClient{
-		logger:      logger,
 		reqQueue:    make(chan *reqResWithContext, reqQueueSize),
+		flushTimer:  timer.NewThrottleTimer("socketClient", flushThrottleMS),
 		mustConnect: mustConnect,
-		addr:        addr,
-		reqSent:     list.New(),
-		resCb:       nil,
+
+		addr:    addr,
+		reqSent: list.New(),
+		resCb:   nil,
 	}
-	cli.BaseService = *service.NewBaseService(logger, "socketClient", cli)
+	cli.BaseService = *service.NewBaseService(nil, "socketClient", cli)
 	return cli
 }
 
 // OnStart implements Service by connecting to the server and spawning reading
 // and writing goroutines.
-func (cli *socketClient) OnStart(ctx context.Context) error {
+func (cli *socketClient) OnStart() error {
 	var (
 		err  error
 		conn net.Conn
@@ -79,15 +82,15 @@ func (cli *socketClient) OnStart(ctx context.Context) error {
 			if cli.mustConnect {
 				return err
 			}
-			cli.logger.Error(fmt.Sprintf("abci.socketClient failed to connect to %v.  Retrying after %vs...",
+			cli.Logger.Error(fmt.Sprintf("abci.socketClient failed to connect to %v.  Retrying after %vs...",
 				cli.addr, dialRetryIntervalSeconds), "err", err)
 			time.Sleep(time.Second * dialRetryIntervalSeconds)
 			continue
 		}
 		cli.conn = conn
 
-		go cli.sendRequestsRoutine(ctx, conn)
-		go cli.recvResponseRoutine(ctx, conn)
+		go cli.sendRequestsRoutine(conn)
+		go cli.recvResponseRoutine(conn)
 
 		return nil
 	}
@@ -99,13 +102,14 @@ func (cli *socketClient) OnStop() {
 		cli.conn.Close()
 	}
 
-	cli.drainQueue()
+	cli.flushQueue()
+	cli.flushTimer.Stop()
 }
 
 // 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
 }
 
@@ -121,41 +125,48 @@ func (cli *socketClient) SetResponseCallback(resCb Callback) {
 
 //----------------------------------------
 
-func (cli *socketClient) sendRequestsRoutine(ctx context.Context, conn io.Writer) {
-	bw := bufio.NewWriter(conn)
+func (cli *socketClient) sendRequestsRoutine(conn io.Writer) {
+	w := bufio.NewWriter(conn)
 	for {
 		select {
-		case <-ctx.Done():
-			return
 		case reqres := <-cli.reqQueue:
-			if ctx.Err() != nil {
-				return
-			}
+			// cli.Logger.Debug("Sent request", "requestType", reflect.TypeOf(reqres.Request), "request", reqres.Request)
 
 			if reqres.C.Err() != nil {
-				cli.logger.Debug("Request's context is done", "req", reqres.R, "err", reqres.C.Err())
+				cli.Logger.Debug("Request's context is done", "req", reqres.R, "err", reqres.C.Err())
 				continue
 			}
-			cli.willSendReq(reqres.R)
 
-			if err := types.WriteMessage(reqres.R.Request, bw); err != nil {
+			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 err := bw.Flush(); err != nil {
-				cli.stopForError(fmt.Errorf("flush buffer: %w", err))
-				return
+
+			// If it's a flush request, flush the current buffer.
+			if _, ok := reqres.R.Request.Value.(*types.Request_Flush); ok {
+				err = w.Flush()
+				if err != nil {
+					cli.stopForError(fmt.Errorf("flush buffer: %w", err))
+					return
+				}
 			}
+		case <-cli.flushTimer.Ch: // flush queue
+			select {
+			case cli.reqQueue <- &reqResWithContext{R: NewReqRes(types.ToRequestFlush()), C: context.Background()}:
+			default:
+				// Probably will fill the buffer, or retry later.
+			}
+		case <-cli.Quit():
+			return
 		}
 	}
 }
 
-func (cli *socketClient) recvResponseRoutine(ctx context.Context, conn io.Reader) {
+func (cli *socketClient) recvResponseRoutine(conn io.Reader) {
 	r := bufio.NewReader(conn)
 	for {
-		if ctx.Err() != nil {
-			return
-		}
 		var res = &types.Response{}
 		err := types.ReadMessage(r, res)
 		if err != nil {
@@ -163,7 +174,7 @@ func (cli *socketClient) recvResponseRoutine(ctx context.Context, conn io.Reader
 			return
 		}
 
-		// cli.logger.Debug("Received response", "responseType", reflect.TypeOf(res), "response", res)
+		// cli.Logger.Debug("Received response", "responseType", reflect.TypeOf(res), "response", res)
 
 		switch r := res.Value.(type) {
 		case *types.Response_Exception: // app responded with error
@@ -481,6 +492,14 @@ func (cli *socketClient) queueRequest(ctx context.Context, req *types.Request, s
 		}
 	}
 
+	// Maybe auto-flush, or unset auto-flush
+	switch req.Value.(type) {
+	case *types.Request_Flush:
+		cli.flushTimer.Unset()
+	default:
+		cli.flushTimer.Set()
+	}
+
 	return reqres, nil
 }
 
@@ -518,9 +537,7 @@ func queueErr(e error) error {
 	return fmt.Errorf("can't queue req: %w", e)
 }
 
-// drainQueue marks as complete and discards all remaining pending requests
-// from the queue.
-func (cli *socketClient) drainQueue() {
+func (cli *socketClient) flushQueue() {
 	cli.mtx.Lock()
 	defer cli.mtx.Unlock()
 
@@ -530,17 +547,14 @@ func (cli *socketClient) drainQueue() {
 		reqres.Done()
 	}
 
-	// Mark all queued messages as resolved.
-	//
-	// TODO(creachadair): We can't simply range the channel, because it is never
-	// closed, and the writer continues to add work.
-	// See https://github.com/tendermint/tendermint/issues/6996.
+	// mark all queued messages as resolved
+LOOP:
 	for {
 		select {
 		case reqres := <-cli.reqQueue:
 			reqres.R.Done()
 		default:
-			return
+			break LOOP
 		}
 	}
 }
@@ -590,8 +604,8 @@ func (cli *socketClient) stopForError(err error) {
 	cli.err = err
 	cli.mtx.Unlock()
 
-	cli.logger.Info("Stopping abci.socketClient", "reason", err)
+	cli.Logger.Info("Stopping abci.socketClient", "reason", err)
 	if err := cli.Stop(); err != nil {
-		cli.logger.Error("Error stopping abci.socketClient", "err", err)
+		cli.Logger.Error("Error stopping abci.socketClient", "err", err)
 	}
 }

abci/client/socket_client_test.go

@@ -1,4 +1,4 @@
-package abciclient_test
+package abcicli_test
 
 import (
 	"context"
@@ -11,28 +11,35 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/server"
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 )
 
+var ctx = context.Background()
+
 func TestProperSyncCalls(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	app := slowApp{}
-	logger := log.TestingLogger()
 
-	_, c := setupClientServer(ctx, t, logger, app)
+	s, c := setupClientServer(t, app)
+	t.Cleanup(func() {
+		if err := s.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
+	t.Cleanup(func() {
+		if err := c.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
 	resp := make(chan error, 1)
 	go func() {
 		// This is BeginBlockSync unrolled....
 		reqres, err := c.BeginBlockAsync(ctx, types.RequestBeginBlock{})
 		assert.NoError(t, err)
-		err = c.FlushSync(ctx)
+		err = c.FlushSync(context.Background())
 		assert.NoError(t, err)
 		res := reqres.Response.GetBeginBlock()
 		assert.NotNil(t, res)
@@ -48,29 +55,64 @@ func TestProperSyncCalls(t *testing.T) {
 	}
 }
 
-func setupClientServer(
-	ctx context.Context,
-	t *testing.T,
-	logger log.Logger,
-	app types.Application,
-) (service.Service, abciclient.Client) {
-	t.Helper()
+func TestHangingSyncCalls(t *testing.T) {
+	app := slowApp{}
 
+	s, c := setupClientServer(t, app)
+	t.Cleanup(func() {
+		if err := s.Stop(); err != nil {
+			t.Log(err)
+		}
+	})
+	t.Cleanup(func() {
+		if err := c.Stop(); err != nil {
+			t.Log(err)
+		}
+	})
+
+	resp := make(chan error, 1)
+	go func() {
+		// Start BeginBlock and flush it
+		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()
+		assert.NoError(t, err)
+
+		// wait for the response from BeginBlock
+		reqres.Wait()
+		flush.Wait()
+		resp <- c.Error()
+	}()
+
+	select {
+	case <-time.After(time.Second):
+		require.Fail(t, "No response arrived")
+	case err, ok := <-resp:
+		require.True(t, ok, "Must not close channel")
+		assert.Error(t, err, "We should get EOF error")
+	}
+}
+
+func setupClientServer(t *testing.T, app types.Application) (
+	service.Service, abcicli.Client) {
 	// some port between 20k and 30k
 	port := 20000 + rand.Int31()%10000
 	addr := fmt.Sprintf("localhost:%d", port)
 
-	s, err := server.NewServer(logger, addr, "socket", app)
+	s, err := server.NewServer(addr, "socket", app)
+	require.NoError(t, err)
+	err = s.Start()
 	require.NoError(t, err)
-	require.NoError(t, s.Start(ctx))
-	t.Cleanup(s.Wait)
 
-	c := abciclient.NewSocketClient(logger, addr, true)
-	require.NoError(t, c.Start(ctx))
-	t.Cleanup(c.Wait)
-
-	require.True(t, s.IsRunning())
-	require.True(t, c.IsRunning())
+	c := abcicli.NewSocketClient(addr, true)
+	err = c.Start()
+	require.NoError(t, err)
 
 	return s, c
 }

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

@@ -2,21 +2,22 @@ package main
 
 import (
 	"bufio"
+	"context"
 	"encoding/hex"
 	"errors"
 	"fmt"
 	"io"
 	"os"
-	"os/signal"
 	"strings"
-	"syscall"
 
 	"github.com/spf13/cobra"
 
 	"github.com/tendermint/tendermint/libs/log"
+	tmos "github.com/tendermint/tendermint/libs/os"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
+	"github.com/tendermint/tendermint/abci/example/counter"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/abci/server"
 	servertest "github.com/tendermint/tendermint/abci/tests/server"
@@ -27,8 +28,10 @@ import (
 
 // client is a global variable so it can be reused by the console
 var (
-	client abciclient.Client
+	client abcicli.Client
 	logger log.Logger
+
+	ctx = context.Background()
 )
 
 // flags
@@ -44,6 +47,9 @@ var (
 	flagHeight int
 	flagProve  bool
 
+	// counter
+	flagSerial bool
+
 	// kvstore
 	flagPersist string
 )
@@ -55,22 +61,27 @@ var RootCmd = &cobra.Command{
 	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
 
 		switch cmd.Use {
-		case "kvstore", "version":
+		case "counter", "kvstore": // for the examples apps, don't pre-run
+			return nil
+		case "version": // skip running for version command
 			return nil
 		}
 
 		if logger == nil {
-			logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
-		}
-
-		if client == nil {
-			var err error
-			client, err = abciclient.NewClient(logger.With("module", "abci-client"), flagAddress, flagAbci, false)
+			allowLevel, err := log.AllowLevel(flagLogLevel)
 			if err != nil {
 				return err
 			}
-
-			if err := client.Start(cmd.Context()); err != nil {
+			logger = log.NewFilter(log.NewTMLogger(log.NewSyncWriter(os.Stdout)), allowLevel)
+		}
+		if client == nil {
+			var err error
+			client, err = abcicli.NewClient(flagAddress, flagAbci, false)
+			if err != nil {
+				return err
+			}
+			client.SetLogger(logger.With("module", "abci-client"))
+			if err := client.Start(); err != nil {
 				return err
 			}
 		}
@@ -127,6 +138,10 @@ func addQueryFlags() {
 		"whether or not to return a merkle proof of the query result")
 }
 
+func addCounterFlags() {
+	counterCmd.PersistentFlags().BoolVarP(&flagSerial, "serial", "", false, "enforce incrementing (serial) transactions")
+}
+
 func addKVStoreFlags() {
 	kvstoreCmd.PersistentFlags().StringVarP(&flagPersist, "persist", "", "", "directory to use for a database")
 }
@@ -145,6 +160,8 @@ func addCommands() {
 	RootCmd.AddCommand(queryCmd)
 
 	// examples
+	addCounterFlags()
+	RootCmd.AddCommand(counterCmd)
 	addKVStoreFlags()
 	RootCmd.AddCommand(kvstoreCmd)
 }
@@ -244,6 +261,14 @@ var queryCmd = &cobra.Command{
 	RunE:  cmdQuery,
 }
 
+var counterCmd = &cobra.Command{
+	Use:   "counter",
+	Short: "ABCI demo example",
+	Long:  "ABCI demo example",
+	Args:  cobra.ExactArgs(0),
+	RunE:  cmdCounter,
+}
+
 var kvstoreCmd = &cobra.Command{
 	Use:   "kvstore",
 	Short: "ABCI demo example",
@@ -290,24 +315,23 @@ func compose(fs []func() error) error {
 }
 
 func cmdTest(cmd *cobra.Command, args []string) error {
-	ctx := cmd.Context()
 	return compose(
 		[]func() error{
-			func() error { return servertest.InitChain(ctx, client) },
-			func() error { return servertest.Commit(ctx, client, nil) },
-			func() error { return servertest.DeliverTx(ctx, client, []byte("abc"), code.CodeTypeBadNonce, nil) },
-			func() error { return servertest.Commit(ctx, client, nil) },
-			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00}, code.CodeTypeOK, nil) },
-			func() error { return servertest.Commit(ctx, client, []byte{0, 0, 0, 0, 0, 0, 0, 1}) },
-			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00}, code.CodeTypeBadNonce, nil) },
-			func() error { return servertest.DeliverTx(ctx, client, []byte{0x01}, code.CodeTypeOK, nil) },
-			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00, 0x02}, code.CodeTypeOK, nil) },
-			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00, 0x03}, code.CodeTypeOK, nil) },
-			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00, 0x00, 0x04}, code.CodeTypeOK, nil) },
+			func() error { return servertest.InitChain(client) },
+			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) },
+			func() error { return servertest.DeliverTx(client, []byte{0x00}, code.CodeTypeOK, nil) },
+			func() error { return servertest.Commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 1}) },
+			func() error { return servertest.DeliverTx(client, []byte{0x00}, code.CodeTypeBadNonce, nil) },
+			func() error { return servertest.DeliverTx(client, []byte{0x01}, code.CodeTypeOK, nil) },
+			func() error { return servertest.DeliverTx(client, []byte{0x00, 0x02}, code.CodeTypeOK, nil) },
+			func() error { return servertest.DeliverTx(client, []byte{0x00, 0x03}, code.CodeTypeOK, nil) },
+			func() error { return servertest.DeliverTx(client, []byte{0x00, 0x00, 0x04}, code.CodeTypeOK, nil) },
 			func() error {
-				return servertest.DeliverTx(ctx, client, []byte{0x00, 0x00, 0x06}, code.CodeTypeBadNonce, nil)
+				return servertest.DeliverTx(client, []byte{0x00, 0x00, 0x06}, code.CodeTypeBadNonce, nil)
 			},
-			func() error { return servertest.Commit(ctx, client, []byte{0, 0, 0, 0, 0, 0, 0, 5}) },
+			func() error { return servertest.Commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5}) },
 		})
 }
 
@@ -442,15 +466,13 @@ func cmdEcho(cmd *cobra.Command, args []string) error {
 	if len(args) > 0 {
 		msg = args[0]
 	}
-	res, err := client.EchoSync(cmd.Context(), msg)
+	res, err := client.EchoSync(ctx, msg)
 	if err != nil {
 		return err
 	}
-
 	printResponse(cmd, args, response{
 		Data: []byte(res.Message),
 	})
-
 	return nil
 }
 
@@ -460,7 +482,7 @@ func cmdInfo(cmd *cobra.Command, args []string) error {
 	if len(args) == 1 {
 		version = args[0]
 	}
-	res, err := client.InfoSync(cmd.Context(), types.RequestInfo{Version: version})
+	res, err := client.InfoSync(ctx, types.RequestInfo{Version: version})
 	if err != nil {
 		return err
 	}
@@ -485,7 +507,7 @@ func cmdDeliverTx(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	res, err := client.DeliverTxSync(cmd.Context(), types.RequestDeliverTx{Tx: txBytes})
+	res, err := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
 	if err != nil {
 		return err
 	}
@@ -511,7 +533,7 @@ func cmdCheckTx(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	res, err := client.CheckTxSync(cmd.Context(), types.RequestCheckTx{Tx: txBytes})
+	res, err := client.CheckTxSync(ctx, types.RequestCheckTx{Tx: txBytes})
 	if err != nil {
 		return err
 	}
@@ -526,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(cmd.Context())
+	res, err := client.CommitSync(ctx)
 	if err != nil {
 		return err
 	}
@@ -551,7 +573,7 @@ func cmdQuery(cmd *cobra.Command, args []string) error {
 		return err
 	}
 
-	resQuery, err := client.QuerySync(cmd.Context(), types.RequestQuery{
+	resQuery, err := client.QuerySync(ctx, types.RequestQuery{
 		Data:   queryBytes,
 		Path:   flagPath,
 		Height: int64(flagHeight),
@@ -574,8 +596,34 @@ func cmdQuery(cmd *cobra.Command, args []string) error {
 	return nil
 }
 
+func cmdCounter(cmd *cobra.Command, args []string) error {
+	app := counter.NewApplication(flagSerial)
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+
+	// Start the listener
+	srv, err := server.NewServer(flagAddress, flagAbci, app)
+	if err != nil {
+		return err
+	}
+	srv.SetLogger(logger.With("module", "abci-server"))
+	if err := srv.Start(); err != nil {
+		return err
+	}
+
+	// Stop upon receiving SIGTERM or CTRL-C.
+	tmos.TrapSignal(logger, func() {
+		// Cleanup
+		if err := srv.Stop(); err != nil {
+			logger.Error("Error while stopping server", "err", err)
+		}
+	})
+
+	// Run forever.
+	select {}
+}
+
 func cmdKVStore(cmd *cobra.Command, args []string) error {
-	logger := log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
 
 	// Create the application - in memory or persisted to disk
 	var app types.Application
@@ -587,21 +635,25 @@ func cmdKVStore(cmd *cobra.Command, args []string) error {
 	}
 
 	// Start the listener
-	srv, err := server.NewServer(logger.With("module", "abci-server"), flagAddress, flagAbci, app)
+	srv, err := server.NewServer(flagAddress, flagAbci, app)
 	if err != nil {
 		return err
 	}
-
-	ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM)
-	defer cancel()
-
-	if err := srv.Start(ctx); err != nil {
+	srv.SetLogger(logger.With("module", "abci-server"))
+	if err := srv.Start(); err != nil {
 		return err
 	}
 
+	// Stop upon receiving SIGTERM or CTRL-C.
+	tmos.TrapSignal(logger, func() {
+		// Cleanup
+		if err := srv.Stop(); err != nil {
+			logger.Error("Error while stopping server", "err", err)
+		}
+	})
+
 	// Run forever.
-	<-ctx.Done()
-	return nil
+	select {}
 }
 
 //--------------------------------------------------------------------------------

abci/example/counter/counter.go

@@ -0,0 +1,86 @@
+package counter
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/tendermint/tendermint/abci/example/code"
+	"github.com/tendermint/tendermint/abci/types"
+)
+
+type Application struct {
+	types.BaseApplication
+
+	hashCount int
+	txCount   int
+	serial    bool
+}
+
+func NewApplication(serial bool) *Application {
+	return &Application{serial: serial}
+}
+
+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) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverTx {
+	if app.serial {
+		if len(req.Tx) > 8 {
+			return types.ResponseDeliverTx{
+				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)
+		if txValue != uint64(app.txCount) {
+			return types.ResponseDeliverTx{
+				Code: code.CodeTypeBadNonce,
+				Log:  fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue)}
+		}
+	}
+	app.txCount++
+	return types.ResponseDeliverTx{Code: code.CodeTypeOK}
+}
+
+func (app *Application) CheckTx(req types.RequestCheckTx) types.ResponseCheckTx {
+	if app.serial {
+		if len(req.Tx) > 8 {
+			return 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)
+		if txValue < uint64(app.txCount) {
+			return types.ResponseCheckTx{
+				Code: code.CodeTypeBadNonce,
+				Log:  fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue)}
+		}
+	}
+	return types.ResponseCheckTx{Code: code.CodeTypeOK}
+}
+
+func (app *Application) Commit() (resp types.ResponseCommit) {
+	app.hashCount++
+	if app.txCount == 0 {
+		return types.ResponseCommit{}
+	}
+	hash := make([]byte, 8)
+	binary.BigEndian.PutUint64(hash, uint64(app.txCount))
+	return types.ResponseCommit{Data: hash}
+}
+
+func (app *Application) Query(reqQuery types.RequestQuery) types.ResponseQuery {
+	switch reqQuery.Path {
+	case "hash":
+		return types.ResponseQuery{Value: []byte(fmt.Sprintf("%v", app.hashCount))}
+	case "tx":
+		return types.ResponseQuery{Value: []byte(fmt.Sprintf("%v", app.txCount))}
+	default:
+		return types.ResponseQuery{Log: fmt.Sprintf("Invalid query path. Expected hash or tx, got %v", reqQuery.Path)}
+	}
+}

abci/example/example_test.go

@@ -17,7 +17,7 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abciserver "github.com/tendermint/tendermint/abci/server"
@@ -29,48 +29,47 @@ func init() {
 }
 
 func TestKVStore(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	fmt.Println("### Testing KVStore")
-	testStream(ctx, t, kvstore.NewApplication())
+	testStream(t, kvstore.NewApplication())
 }
 
 func TestBaseApp(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
 	fmt.Println("### Testing BaseApp")
-	testStream(ctx, t, types.NewBaseApplication())
+	testStream(t, types.NewBaseApplication())
 }
 
 func TestGRPC(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	fmt.Println("### Testing GRPC")
-	testGRPCSync(ctx, t, types.NewGRPCApplication(types.NewBaseApplication()))
+	testGRPCSync(t, types.NewGRPCApplication(types.NewBaseApplication()))
 }
 
-func testStream(ctx context.Context, t *testing.T, app types.Application) {
-	t.Helper()
-
+func testStream(t *testing.T, app types.Application) {
 	const numDeliverTxs = 20000
 	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
 	defer os.Remove(socketFile)
 	socket := fmt.Sprintf("unix://%v", socketFile)
-	logger := log.TestingLogger()
+
 	// Start the listener
-	server := abciserver.NewSocketServer(logger.With("module", "abci-server"), socket, app)
-	t.Cleanup(server.Wait)
-	err := server.Start(ctx)
+	server := abciserver.NewSocketServer(socket, app)
+	server.SetLogger(log.TestingLogger().With("module", "abci-server"))
+	err := server.Start()
 	require.NoError(t, err)
+	t.Cleanup(func() {
+		if err := server.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
 	// Connect to the socket
-	client := abciclient.NewSocketClient(log.TestingLogger().With("module", "abci-client"), socket, false)
-	t.Cleanup(client.Wait)
-
-	err = client.Start(ctx)
+	client := abcicli.NewSocketClient(socket, false)
+	client.SetLogger(log.TestingLogger().With("module", "abci-client"))
+	err = client.Start()
 	require.NoError(t, err)
+	t.Cleanup(func() {
+		if err := client.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
 	done := make(chan struct{})
 	counter := 0
@@ -99,6 +98,8 @@ func testStream(ctx context.Context, t *testing.T, app types.Application) {
 		}
 	})
 
+	ctx := context.Background()
+
 	// Write requests
 	for counter := 0; counter < numDeliverTxs; counter++ {
 		// Send request
@@ -126,20 +127,24 @@ func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
 	return tmnet.Connect(addr)
 }
 
-func testGRPCSync(ctx context.Context, t *testing.T, app types.ABCIApplicationServer) {
+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)
-	logger := log.TestingLogger()
-	// Start the listener
-	server := abciserver.NewGRPCServer(logger.With("module", "abci-server"), socket, app)
 
-	if err := server.Start(ctx); err != nil {
+	// Start the listener
+	server := abciserver.NewGRPCServer(socket, app)
+	server.SetLogger(log.TestingLogger().With("module", "abci-server"))
+	if err := server.Start(); err != nil {
 		t.Fatalf("Error starting GRPC server: %v", err.Error())
 	}
 
-	t.Cleanup(func() { server.Wait() })
+	t.Cleanup(func() {
+		if err := server.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
 	// Connect to the socket
 	conn, err := grpc.Dial(socket, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))

abci/example/kvstore/kvstore_test.go

@@ -3,7 +3,7 @@ package kvstore
 import (
 	"context"
 	"fmt"
-	"os"
+	"io/ioutil"
 	"sort"
 	"testing"
 
@@ -12,7 +12,7 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
 	abciserver "github.com/tendermint/tendermint/abci/server"
 	"github.com/tendermint/tendermint/abci/types"
@@ -24,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)
@@ -72,7 +74,7 @@ func TestKVStoreKV(t *testing.T) {
 }
 
 func TestPersistentKVStoreKV(t *testing.T) {
-	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
+	dir, err := ioutil.TempDir("/tmp", "abci-kvstore-test") // TODO
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -88,7 +90,7 @@ func TestPersistentKVStoreKV(t *testing.T) {
 }
 
 func TestPersistentKVStoreInfo(t *testing.T) {
-	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
+	dir, err := ioutil.TempDir("/tmp", "abci-kvstore-test") // TODO
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -120,7 +122,7 @@ func TestPersistentKVStoreInfo(t *testing.T) {
 
 // add a validator, remove a validator, update a validator
 func TestValUpdates(t *testing.T) {
-	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
+	dir, err := ioutil.TempDir("/tmp", "abci-kvstore-test") // TODO
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -227,103 +229,103 @@ func valsEqual(t *testing.T, vals1, vals2 []types.ValidatorUpdate) {
 	}
 }
 
-func makeSocketClientServer(
-	ctx context.Context,
-	t *testing.T,
-	logger log.Logger,
-	app types.Application,
-	name string,
-) (abciclient.Client, service.Service, error) {
-
-	ctx, cancel := context.WithCancel(ctx)
-	t.Cleanup(cancel)
-
+func makeSocketClientServer(app types.Application, name string) (abcicli.Client, service.Service, error) {
 	// Start the listener
 	socket := fmt.Sprintf("unix://%s.sock", name)
+	logger := log.TestingLogger()
 
-	server := abciserver.NewSocketServer(logger.With("module", "abci-server"), socket, app)
-	if err := server.Start(ctx); err != nil {
-		cancel()
+	server := abciserver.NewSocketServer(socket, app)
+	server.SetLogger(logger.With("module", "abci-server"))
+	if err := server.Start(); err != nil {
 		return nil, nil, err
 	}
 
 	// Connect to the socket
-	client := abciclient.NewSocketClient(logger.With("module", "abci-client"), socket, false)
-	if err := client.Start(ctx); err != nil {
-		cancel()
+	client := abcicli.NewSocketClient(socket, false)
+	client.SetLogger(logger.With("module", "abci-client"))
+	if err := client.Start(); err != nil {
+		if err = server.Stop(); err != nil {
+			return nil, nil, err
+		}
 		return nil, nil, err
 	}
 
 	return client, server, nil
 }
 
-func makeGRPCClientServer(
-	ctx context.Context,
-	t *testing.T,
-	logger log.Logger,
-	app types.Application,
-	name string,
-) (abciclient.Client, service.Service, error) {
-	ctx, cancel := context.WithCancel(ctx)
-	t.Cleanup(cancel)
+func makeGRPCClientServer(app types.Application, name string) (abcicli.Client, service.Service, error) {
 	// Start the listener
 	socket := fmt.Sprintf("unix://%s.sock", name)
+	logger := log.TestingLogger()
 
 	gapp := types.NewGRPCApplication(app)
-	server := abciserver.NewGRPCServer(logger.With("module", "abci-server"), socket, gapp)
-
-	if err := server.Start(ctx); err != nil {
-		cancel()
+	server := abciserver.NewGRPCServer(socket, gapp)
+	server.SetLogger(logger.With("module", "abci-server"))
+	if err := server.Start(); err != nil {
 		return nil, nil, err
 	}
 
-	client := abciclient.NewGRPCClient(logger.With("module", "abci-client"), socket, true)
-
-	if err := client.Start(ctx); err != nil {
-		cancel()
+	client := abcicli.NewGRPCClient(socket, true)
+	client.SetLogger(logger.With("module", "abci-client"))
+	if err := client.Start(); err != nil {
+		if err := server.Stop(); err != nil {
+			return nil, nil, err
+		}
 		return nil, nil, err
 	}
 	return client, server, nil
 }
 
 func TestClientServer(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	logger := log.TestingLogger()
-
 	// set up socket app
 	kvstore := NewApplication()
-	client, server, err := makeSocketClientServer(ctx, t, logger, kvstore, "kvstore-socket")
+	client, server, err := makeSocketClientServer(kvstore, "kvstore-socket")
 	require.NoError(t, err)
-	t.Cleanup(func() { cancel(); server.Wait() })
-	t.Cleanup(func() { cancel(); client.Wait() })
+	t.Cleanup(func() {
+		if err := server.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
+	t.Cleanup(func() {
+		if err := client.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
-	runClientTests(ctx, t, client)
+	runClientTests(t, client)
 
 	// set up grpc app
 	kvstore = NewApplication()
-	gclient, gserver, err := makeGRPCClientServer(ctx, t, logger, kvstore, "/tmp/kvstore-grpc")
+	gclient, gserver, err := makeGRPCClientServer(kvstore, "kvstore-grpc")
 	require.NoError(t, err)
 
-	t.Cleanup(func() { cancel(); gserver.Wait() })
-	t.Cleanup(func() { cancel(); gclient.Wait() })
+	t.Cleanup(func() {
+		if err := gserver.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
+	t.Cleanup(func() {
+		if err := gclient.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
-	runClientTests(ctx, t, gclient)
+	runClientTests(t, gclient)
 }
 
-func runClientTests(ctx context.Context, t *testing.T, client abciclient.Client) {
+func runClientTests(t *testing.T, client abcicli.Client) {
 	// run some tests....
 	key := testKey
 	value := key
 	tx := []byte(key)
-	testClient(ctx, t, client, tx, key, value)
+	testClient(t, client, tx, key, value)
 
 	value = testValue
 	tx = []byte(key + "=" + value)
-	testClient(ctx, t, client, tx, key, value)
+	testClient(t, client, tx, key, value)
 }
 
-func testClient(ctx context.Context, t *testing.T, app abciclient.Client, tx []byte, key, value string) {
+func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string) {
 	ar, err := app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
 	require.NoError(t, err)
 	require.False(t, ar.IsErr(), ar)

abci/example/kvstore/persistent_kvstore.go

@@ -11,9 +11,9 @@ import (
 
 	"github.com/tendermint/tendermint/abci/example/code"
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto/encoding"
+	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/libs/log"
-	cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto"
+	pc "github.com/tendermint/tendermint/proto/tendermint/crypto"
 )
 
 const (
@@ -30,7 +30,7 @@ type PersistentKVStoreApplication struct {
 	// validator set
 	ValUpdates []types.ValidatorUpdate
 
-	valAddrToPubKeyMap map[string]cryptoproto.PublicKey
+	valAddrToPubKeyMap map[string]pc.PublicKey
 
 	logger log.Logger
 }
@@ -46,7 +46,7 @@ func NewPersistentKVStoreApplication(dbDir string) *PersistentKVStoreApplication
 
 	return &PersistentKVStoreApplication{
 		app:                &Application{state: state},
-		valAddrToPubKeyMap: make(map[string]cryptoproto.PublicKey),
+		valAddrToPubKeyMap: make(map[string]pc.PublicKey),
 		logger:             log.NewNopLogger(),
 	}
 }
@@ -194,8 +194,8 @@ func (app *PersistentKVStoreApplication) Validators() (validators []types.Valida
 	return
 }
 
-func MakeValSetChangeTx(pubkey cryptoproto.PublicKey, power int64) []byte {
-	pk, err := encoding.PubKeyFromProto(pubkey)
+func MakeValSetChangeTx(pubkey pc.PublicKey, power int64) []byte {
+	pk, err := cryptoenc.PubKeyFromProto(pubkey)
 	if err != nil {
 		panic(err)
 	}
@@ -243,7 +243,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon
 
 // add, update, or remove a validator
 func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate) types.ResponseDeliverTx {
-	pubkey, err := encoding.PubKeyFromProto(v.PubKey)
+	pubkey, err := cryptoenc.PubKeyFromProto(v.PubKey)
 	if err != nil {
 		panic(fmt.Errorf("can't decode public key: %w", err))
 	}

abci/server/grpc_server.go

@@ -1,20 +1,17 @@
 package server
 
 import (
-	"context"
 	"net"
 
 	"google.golang.org/grpc"
 
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 	"github.com/tendermint/tendermint/libs/service"
 )
 
 type GRPCServer struct {
 	service.BaseService
-	logger log.Logger
 
 	proto    string
 	addr     string
@@ -25,21 +22,20 @@ type GRPCServer struct {
 }
 
 // NewGRPCServer returns a new gRPC ABCI server
-func NewGRPCServer(logger log.Logger, protoAddr string, app types.ABCIApplicationServer) service.Service {
+func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) service.Service {
 	proto, addr := tmnet.ProtocolAndAddress(protoAddr)
 	s := &GRPCServer{
-		logger:   logger,
 		proto:    proto,
 		addr:     addr,
 		listener: nil,
 		app:      app,
 	}
-	s.BaseService = *service.NewBaseService(logger, "ABCIServer", s)
+	s.BaseService = *service.NewBaseService(nil, "ABCIServer", s)
 	return s
 }
 
 // OnStart starts the gRPC service.
-func (s *GRPCServer) OnStart(ctx context.Context) error {
+func (s *GRPCServer) OnStart() error {
 
 	ln, err := net.Listen(s.proto, s.addr)
 	if err != nil {
@@ -50,15 +46,10 @@ func (s *GRPCServer) OnStart(ctx context.Context) error {
 	s.server = grpc.NewServer()
 	types.RegisterABCIApplicationServer(s.server, s.app)
 
-	s.logger.Info("Listening", "proto", s.proto, "addr", s.addr)
+	s.Logger.Info("Listening", "proto", s.proto, "addr", s.addr)
 	go func() {
-		go func() {
-			<-ctx.Done()
-			s.server.GracefulStop()
-		}()
-
 		if err := s.server.Serve(s.listener); err != nil {
-			s.logger.Error("Error serving gRPC server", "err", err)
+			s.Logger.Error("Error serving gRPC server", "err", err)
 		}
 	}()
 	return nil

abci/server/server.go

@@ -12,18 +12,17 @@ import (
 	"fmt"
 
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 )
 
-func NewServer(logger log.Logger, protoAddr, transport string, app types.Application) (service.Service, error) {
+func NewServer(protoAddr, transport string, app types.Application) (service.Service, error) {
 	var s service.Service
 	var err error
 	switch transport {
 	case "socket":
-		s = NewSocketServer(logger, protoAddr, app)
+		s = NewSocketServer(protoAddr, app)
 	case "grpc":
-		s = NewGRPCServer(logger, protoAddr, types.NewGRPCApplication(app))
+		s = NewGRPCServer(protoAddr, types.NewGRPCApplication(app))
 	default:
 		err = fmt.Errorf("unknown server type %s", transport)
 	}

abci/server/socket_server.go

@@ -2,75 +2,78 @@ package server
 
 import (
 	"bufio"
-	"context"
 	"fmt"
 	"io"
 	"net"
+	"os"
 	"runtime"
-	"sync"
 
 	"github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
+	tmlog "github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 	"github.com/tendermint/tendermint/libs/service"
+	tmsync "github.com/tendermint/tendermint/libs/sync"
 )
 
 // var maxNumberConnections = 2
 
 type SocketServer struct {
 	service.BaseService
-	logger log.Logger
+	isLoggerSet bool
 
 	proto    string
 	addr     string
 	listener net.Listener
 
-	connsMtx   sync.Mutex
+	connsMtx   tmsync.Mutex
 	conns      map[int]net.Conn
 	nextConnID int
 
-	appMtx sync.Mutex
+	appMtx tmsync.Mutex
 	app    types.Application
 }
 
-func NewSocketServer(logger log.Logger, protoAddr string, app types.Application) service.Service {
+func NewSocketServer(protoAddr string, app types.Application) service.Service {
 	proto, addr := tmnet.ProtocolAndAddress(protoAddr)
 	s := &SocketServer{
-		logger:   logger,
 		proto:    proto,
 		addr:     addr,
 		listener: nil,
 		app:      app,
 		conns:    make(map[int]net.Conn),
 	}
-	s.BaseService = *service.NewBaseService(logger, "ABCIServer", s)
+	s.BaseService = *service.NewBaseService(nil, "ABCIServer", s)
 	return s
 }
 
-func (s *SocketServer) OnStart(ctx context.Context) error {
+func (s *SocketServer) SetLogger(l tmlog.Logger) {
+	s.BaseService.SetLogger(l)
+	s.isLoggerSet = true
+}
+
+func (s *SocketServer) OnStart() error {
 	ln, err := net.Listen(s.proto, s.addr)
 	if err != nil {
 		return err
 	}
 
 	s.listener = ln
-	go s.acceptConnectionsRoutine(ctx)
+	go s.acceptConnectionsRoutine()
 
 	return nil
 }
 
 func (s *SocketServer) OnStop() {
 	if err := s.listener.Close(); err != nil {
-		s.logger.Error("Error closing listener", "err", err)
+		s.Logger.Error("Error closing listener", "err", err)
 	}
 
 	s.connsMtx.Lock()
 	defer s.connsMtx.Unlock()
-
 	for id, conn := range s.conns {
 		delete(s.conns, id)
 		if err := conn.Close(); err != nil {
-			s.logger.Error("Error closing connection", "id", id, "conn", conn, "err", err)
+			s.Logger.Error("Error closing connection", "id", id, "conn", conn, "err", err)
 		}
 	}
 }
@@ -100,25 +103,20 @@ func (s *SocketServer) rmConn(connID int) error {
 	return conn.Close()
 }
 
-func (s *SocketServer) acceptConnectionsRoutine(ctx context.Context) {
+func (s *SocketServer) acceptConnectionsRoutine() {
 	for {
-		if ctx.Err() != nil {
-			return
-
-		}
-
 		// Accept a connection
-		s.logger.Info("Waiting for new connection...")
+		s.Logger.Info("Waiting for new connection...")
 		conn, err := s.listener.Accept()
 		if err != nil {
 			if !s.IsRunning() {
 				return // Ignore error from listener closing.
 			}
-			s.logger.Error("Failed to accept connection", "err", err)
+			s.Logger.Error("Failed to accept connection", "err", err)
 			continue
 		}
 
-		s.logger.Info("Accepted a new connection")
+		s.Logger.Info("Accepted a new connection")
 
 		connID := s.addConn(conn)
 
@@ -126,46 +124,35 @@ func (s *SocketServer) acceptConnectionsRoutine(ctx context.Context) {
 		responses := make(chan *types.Response, 1000) // A channel to buffer responses
 
 		// Read requests from conn and deal with them
-		go s.handleRequests(ctx, closeConn, conn, responses)
+		go s.handleRequests(closeConn, conn, responses)
 		// Pull responses from 'responses' and write them to conn.
-		go s.handleResponses(ctx, closeConn, conn, responses)
+		go s.handleResponses(closeConn, conn, responses)
 
 		// Wait until signal to close connection
-		go s.waitForClose(ctx, closeConn, connID)
+		go s.waitForClose(closeConn, connID)
 	}
 }
 
-func (s *SocketServer) waitForClose(ctx context.Context, closeConn chan error, connID int) {
-	defer func() {
-		// Close the connection
-		if err := s.rmConn(connID); err != nil {
-			s.logger.Error("Error closing connection", "err", err)
-		}
-	}()
+func (s *SocketServer) waitForClose(closeConn chan error, connID int) {
+	err := <-closeConn
+	switch {
+	case err == io.EOF:
+		s.Logger.Error("Connection was closed by client")
+	case err != nil:
+		s.Logger.Error("Connection error", "err", err)
+	default:
+		// never happens
+		s.Logger.Error("Connection was closed")
+	}
 
-	select {
-	case <-ctx.Done():
-		return
-	case err := <-closeConn:
-		switch {
-		case err == io.EOF:
-			s.logger.Error("Connection was closed by client")
-		case err != nil:
-			s.logger.Error("Connection error", "err", err)
-		default:
-			// never happens
-			s.logger.Error("Connection was closed")
-		}
+	// Close the connection
+	if err := s.rmConn(connID); err != nil {
+		s.Logger.Error("Error closing connection", "err", err)
 	}
 }
 
 // Read requests from conn and deal with them
-func (s *SocketServer) handleRequests(
-	ctx context.Context,
-	closeConn chan error,
-	conn io.Reader,
-	responses chan<- *types.Response,
-) {
+func (s *SocketServer) handleRequests(closeConn chan error, conn io.Reader, responses chan<- *types.Response) {
 	var count int
 	var bufReader = bufio.NewReader(conn)
 
@@ -177,15 +164,15 @@ func (s *SocketServer) handleRequests(
 			buf := make([]byte, size)
 			buf = buf[:runtime.Stack(buf, false)]
 			err := fmt.Errorf("recovered from panic: %v\n%s", r, buf)
+			if !s.isLoggerSet {
+				fmt.Fprintln(os.Stderr, err)
+			}
 			closeConn <- err
 			s.appMtx.Unlock()
 		}
 	}()
 
 	for {
-		if ctx.Err() != nil {
-			return
-		}
 
 		var req = &types.Request{}
 		err := types.ReadMessage(bufReader, req)
@@ -252,21 +239,23 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 }
 
 // Pull responses from 'responses' and write them to conn.
-func (s *SocketServer) handleResponses(
-	ctx context.Context,
-	closeConn chan error,
-	conn io.Writer,
-	responses <-chan *types.Response,
-) {
-	bw := bufio.NewWriter(conn)
-	for res := range responses {
-		if err := types.WriteMessage(res, bw); err != nil {
+func (s *SocketServer) handleResponses(closeConn chan error, conn io.Writer, responses <-chan *types.Response) {
+	var count int
+	var bufWriter = bufio.NewWriter(conn)
+	for {
+		var res = <-responses
+		err := types.WriteMessage(res, bufWriter)
+		if err != nil {
 			closeConn <- fmt.Errorf("error writing message: %w", err)
 			return
 		}
-		if err := bw.Flush(); err != nil {
-			closeConn <- fmt.Errorf("error flushing write buffer: %w", err)
-			return
+		if _, ok := res.Value.(*types.Response_Flush); ok {
+			err = bufWriter.Flush()
+			if err != nil {
+				closeConn <- fmt.Errorf("error flushing write buffer: %w", err)
+				return
+			}
 		}
+		count++
 	}
 }

abci/tests/client_server_test.go

@@ -1,35 +1,27 @@
 package tests
 
 import (
-	"context"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 
-	abciclientent "github.com/tendermint/tendermint/abci/client"
+	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abciserver "github.com/tendermint/tendermint/abci/server"
-	"github.com/tendermint/tendermint/libs/log"
 )
 
 func TestClientServerNoAddrPrefix(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	const (
-		addr      = "localhost:26658"
-		transport = "socket"
-	)
+	addr := "localhost:26658"
+	transport := "socket"
 	app := kvstore.NewApplication()
-	logger := log.TestingLogger()
 
-	server, err := abciserver.NewServer(logger, addr, transport, app)
+	server, err := abciserver.NewServer(addr, transport, app)
 	assert.NoError(t, err, "expected no error on NewServer")
-	err = server.Start(ctx)
+	err = server.Start()
 	assert.NoError(t, err, "expected no error on server.Start")
 
-	client, err := abciclientent.NewClient(logger, addr, transport, true)
+	client, err := abciclient.NewClient(addr, transport, true)
 	assert.NoError(t, err, "expected no error on NewClient")
-	err = client.Start(ctx)
+	err = client.Start()
 	assert.NoError(t, err, "expected no error on client.Start")
 }

abci/tests/server/client.go

@@ -7,12 +7,14 @@ import (
 	"fmt"
 	mrand "math/rand"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/types"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 )
 
-func InitChain(ctx context.Context, client abciclient.Client) error {
+var ctx = context.Background()
+
+func InitChain(client abcicli.Client) error {
 	total := 10
 	vals := make([]types.ValidatorUpdate, total)
 	for i := 0; i < total; i++ {
@@ -32,7 +34,7 @@ func InitChain(ctx context.Context, client abciclient.Client) error {
 	return nil
 }
 
-func Commit(ctx context.Context, client abciclient.Client, hashExp []byte) error {
+func Commit(client abcicli.Client, hashExp []byte) error {
 	res, err := client.CommitSync(ctx)
 	data := res.Data
 	if err != nil {
@@ -49,7 +51,7 @@ func Commit(ctx context.Context, client abciclient.Client, hashExp []byte) error
 	return nil
 }
 
-func DeliverTx(ctx context.Context, client abciclient.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
+func DeliverTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
 	res, _ := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {
@@ -68,7 +70,7 @@ func DeliverTx(ctx context.Context, client abciclient.Client, txBytes []byte, co
 	return nil
 }
 
-func CheckTx(ctx context.Context, client abciclient.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
+func CheckTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
 	res, _ := client.CheckTxSync(ctx, types.RequestCheckTx{Tx: txBytes})
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {

abci/tests/test_app/app.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+
+	abcicli "github.com/tendermint/tendermint/abci/client"
+	"github.com/tendermint/tendermint/abci/types"
+	"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)
+	if err != nil {
+		panic(err.Error())
+	}
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+	client.SetLogger(logger.With("module", "abcicli"))
+	if err := client.Start(); err != nil {
+		panicf("connecting to abci_app: %v", err.Error())
+	}
+
+	return client
+}
+
+func commit(client abcicli.Client, hashExp []byte) {
+	res, err := client.CommitSync(ctx)
+	if err != nil {
+		panicf("client error: %v", err)
+	}
+	if !bytes.Equal(res.Data, hashExp) {
+		panicf("Commit hash was unexpected. Got %X expected %X", res.Data, hashExp)
+	}
+}
+
+func deliverTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) {
+	res, err := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
+	if err != nil {
+		panicf("client error: %v", err)
+	}
+	if res.Code != codeExp {
+		panicf("DeliverTx response code was unexpected. Got %v expected %v. Log: %v", res.Code, codeExp, res.Log)
+	}
+	if !bytes.Equal(res.Data, dataExp) {
+		panicf("DeliverTx 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

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"time"
+
+	"github.com/tendermint/tendermint/abci/types"
+)
+
+var abciType string
+
+func init() {
+	abciType = os.Getenv("ABCI")
+	if abciType == "" {
+		abciType = "socket"
+	}
+}
+
+func main() {
+	testCounter()
+}
+
+const (
+	maxABCIConnectTries = 10
+)
+
+func ensureABCIIsUp(typ string, n int) error {
+	var err error
+	cmdString := "abci-cli echo hello"
+	if typ == "grpc" {
+		cmdString = "abci-cli --abci grpc echo hello"
+	}
+
+	for i := 0; i < n; i++ {
+		cmd := exec.Command("bash", "-c", cmdString)
+		_, err = cmd.CombinedOutput()
+		if err == nil {
+			break
+		}
+		time.Sleep(500 * time.Millisecond)
+	}
+	return err
+}
+
+func testCounter() {
+	abciApp := os.Getenv("ABCI_APP")
+	if abciApp == "" {
+		panic("No ABCI_APP specified")
+	}
+
+	fmt.Printf("Running %s test with abci=%s\n", abciApp, abciType)
+	subCommand := fmt.Sprintf("abci-cli %s", abciApp)
+	cmd := exec.Command("bash", "-c", subCommand)
+	cmd.Stdout = os.Stdout
+	if err := cmd.Start(); err != nil {
+		log.Fatalf("starting %q err: %v", abciApp, err)
+	}
+	defer func() {
+		if err := cmd.Process.Kill(); err != nil {
+			log.Printf("error on process kill: %v", err)
+		}
+		if err := cmd.Wait(); err != nil {
+			log.Printf("error while waiting for cmd to exit: %v", err)
+		}
+	}()
+
+	if err := ensureABCIIsUp(abciType, maxABCIConnectTries); err != nil {
+		log.Fatalf("echo failed: %v", err) //nolint:gocritic
+	}
+
+	client := startClient(abciType)
+	defer func() {
+		if err := client.Stop(); err != nil {
+			log.Printf("error trying client stop: %v", err)
+		}
+	}()
+
+	// 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{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)
+	commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5})
+}

abci/tests/test_app/test.sh

@@ -0,0 +1,28 @@
+#! /bin/bash
+set -e
+
+# These tests spawn the counter app and server by execing the ABCI_APP command and run some simple client tests against it
+
+# Get the directory of where this script is.
+export PATH="$GOBIN:$PATH"
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ] ; do SOURCE="$(readlink "$SOURCE")"; done
+DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+# Change into that dir because we expect that.
+cd "$DIR"
+
+echo "RUN COUNTER OVER SOCKET"
+# test golang counter
+ABCI_APP="counter" go run -mod=readonly ./*.go
+echo "----------------------"
+
+
+echo "RUN COUNTER OVER GRPC"
+# test golang counter via grpc
+ABCI_APP="counter --abci=grpc" ABCI="grpc" go run -mod=readonly ./*.go
+echo "----------------------"
+
+# test nodejs counter
+# TODO: fix node app
+#ABCI_APP="node $GOPATH/src/github.com/tendermint/js-abci/example/app.js" go test -test.run TestCounter

abci/tests/test_cli/test.sh

@@ -37,6 +37,7 @@ function testExample() {
 }
 
 testExample 1 tests/test_cli/ex1.abci abci-cli kvstore
+testExample 2 tests/test_cli/ex2.abci abci-cli counter
 
 echo ""
 echo "PASS"

abci/types/client.go

@@ -1 +0,0 @@
-package types

abci/types/messages.go

@@ -4,7 +4,7 @@ import (
 	"io"
 
 	"github.com/gogo/protobuf/proto"
-	"github.com/tendermint/tendermint/internal/libs/protoio"
+	"github.com/tendermint/tendermint/libs/protoio"
 )
 
 const (
@@ -15,7 +15,11 @@ const (
 func WriteMessage(msg proto.Message, w io.Writer) error {
 	protoWriter := protoio.NewDelimitedWriter(w)
 	_, err := protoWriter.WriteMsg(msg)
-	return err
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // ReadMessage reads a varint length-delimited protobuf message.

abci/types/pubkey.go

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

abci/types/types.pb.go

@@ -1835,11 +1835,6 @@ type ResponseCheckTx struct {
 	GasUsed   int64   `protobuf:"varint,6,opt,name=gas_used,proto3" json:"gas_used,omitempty"`
 	Events    []Event `protobuf:"bytes,7,rep,name=events,proto3" json:"events,omitempty"`
 	Codespace string  `protobuf:"bytes,8,opt,name=codespace,proto3" json:"codespace,omitempty"`
-	Sender    string  `protobuf:"bytes,9,opt,name=sender,proto3" json:"sender,omitempty"`
-	Priority  int64   `protobuf:"varint,10,opt,name=priority,proto3" json:"priority,omitempty"`
-	// mempool_error is set by Tendermint.
-	// ABCI applications creating a ResponseCheckTX should not set mempool_error.
-	MempoolError string `protobuf:"bytes,11,opt,name=mempool_error,json=mempoolError,proto3" json:"mempool_error,omitempty"`
 }
 
 func (m *ResponseCheckTx) Reset()         { *m = ResponseCheckTx{} }
@@ -1931,27 +1926,6 @@ func (m *ResponseCheckTx) GetCodespace() string {
 	return ""
 }
 
-func (m *ResponseCheckTx) GetSender() string {
-	if m != nil {
-		return m.Sender
-	}
-	return ""
-}
-
-func (m *ResponseCheckTx) GetPriority() int64 {
-	if m != nil {
-		return m.Priority
-	}
-	return 0
-}
-
-func (m *ResponseCheckTx) GetMempoolError() string {
-	if m != nil {
-		return m.MempoolError
-	}
-	return ""
-}
-
 type ResponseDeliverTx struct {
 	Code      uint32  `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
 	Data      []byte  `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
@@ -2964,172 +2938,169 @@ func init() {
 func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) }
 
 var fileDescriptor_252557cfdd89a31a = []byte{
-	// 2627 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0xcd, 0x73, 0xdb, 0xc6,
-	0x15, 0xe7, 0x37, 0x89, 0x47, 0x91, 0xa2, 0xd6, 0x8a, 0x43, 0x33, 0xb6, 0xe4, 0xc0, 0xe3, 0x34,
-	0x76, 0x12, 0xa9, 0x91, 0xc7, 0xae, 0x33, 0xe9, 0x47, 0x44, 0x9a, 0x2e, 0x15, 0xab, 0x92, 0xba,
-	0xa2, 0x9d, 0x49, 0xdb, 0x18, 0x01, 0x89, 0x15, 0x89, 0x98, 0x04, 0x10, 0x60, 0x29, 0x4b, 0x39,
-	0x76, 0xda, 0x8b, 0xa7, 0x07, 0x1f, 0x7b, 0xc9, 0x4c, 0xff, 0x83, 0x5e, 0x7b, 0xea, 0xa9, 0x87,
-	0x1c, 0xda, 0x99, 0x1c, 0x7b, 0xe8, 0xa4, 0x1d, 0xfb, 0xd6, 0x7f, 0xa0, 0xa7, 0xce, 0x74, 0xf6,
-	0x03, 0x20, 0x40, 0x12, 0x22, 0xd5, 0xf4, 0xd6, 0xdb, 0xee, 0xc3, 0x7b, 0x8f, 0xbb, 0x6f, 0xf7,
-	0xfd, 0xf6, 0xb7, 0x6f, 0x09, 0xaf, 0x51, 0x62, 0x19, 0xc4, 0x1d, 0x9a, 0x16, 0xdd, 0xd4, 0x3b,
-	0x5d, 0x73, 0x93, 0x9e, 0x3a, 0xc4, 0xdb, 0x70, 0x5c, 0x9b, 0xda, 0x68, 0x79, 0xfc, 0x71, 0x83,
-	0x7d, 0xac, 0x5d, 0x09, 0x69, 0x77, 0xdd, 0x53, 0x87, 0xda, 0x9b, 0x8e, 0x6b, 0xdb, 0x47, 0x42,
-	0xbf, 0x76, 0x39, 0xf4, 0x99, 0xfb, 0x09, 0x7b, 0x8b, 0x7c, 0x95, 0xc6, 0x4f, 0xc8, 0xa9, 0xff,
-	0xf5, 0xca, 0x94, 0xad, 0xa3, 0xbb, 0xfa, 0xd0, 0xff, 0xbc, 0xde, 0xb3, 0xed, 0xde, 0x80, 0x6c,
-	0xf2, 0x5e, 0x67, 0x74, 0xb4, 0x49, 0xcd, 0x21, 0xf1, 0xa8, 0x3e, 0x74, 0xa4, 0xc2, 0x6a, 0xcf,
-	0xee, 0xd9, 0xbc, 0xb9, 0xc9, 0x5a, 0x42, 0xaa, 0xfe, 0x25, 0x0f, 0x79, 0x4c, 0x3e, 0x1f, 0x11,
-	0x8f, 0xa2, 0x2d, 0xc8, 0x90, 0x6e, 0xdf, 0xae, 0x26, 0xaf, 0x26, 0xdf, 0x2c, 0x6e, 0x5d, 0xde,
-	0x98, 0x98, 0xdc, 0x86, 0xd4, 0x6b, 0x76, 0xfb, 0x76, 0x2b, 0x81, 0xb9, 0x2e, 0xba, 0x0d, 0xd9,
-	0xa3, 0xc1, 0xc8, 0xeb, 0x57, 0x53, 0xdc, 0xe8, 0x4a, 0x9c, 0xd1, 0x7d, 0xa6, 0xd4, 0x4a, 0x60,
-	0xa1, 0xcd, 0x7e, 0xca, 0xb4, 0x8e, 0xec, 0x6a, 0xfa, 0xec, 0x9f, 0xda, 0xb1, 0x8e, 0xf8, 0x4f,
-	0x31, 0x5d, 0x54, 0x07, 0x30, 0x2d, 0x93, 0x6a, 0xdd, 0xbe, 0x6e, 0x5a, 0xd5, 0x0c, 0xb7, 0x7c,
-	0x3d, 0xde, 0xd2, 0xa4, 0x0d, 0xa6, 0xd8, 0x4a, 0x60, 0xc5, 0xf4, 0x3b, 0x6c, 0xb8, 0x9f, 0x8f,
-	0x88, 0x7b, 0x5a, 0xcd, 0x9e, 0x3d, 0xdc, 0x9f, 0x32, 0x25, 0x36, 0x5c, 0xae, 0x8d, 0x9a, 0x50,
-	0xec, 0x90, 0x9e, 0x69, 0x69, 0x9d, 0x81, 0xdd, 0x7d, 0x52, 0xcd, 0x71, 0x63, 0x35, 0xce, 0xb8,
-	0xce, 0x54, 0xeb, 0x4c, 0xb3, 0x95, 0xc0, 0xd0, 0x09, 0x7a, 0xe8, 0xfb, 0x50, 0xe8, 0xf6, 0x49,
-	0xf7, 0x89, 0x46, 0x4f, 0xaa, 0x79, 0xee, 0x63, 0x3d, 0xce, 0x47, 0x83, 0xe9, 0xb5, 0x4f, 0x5a,
-	0x09, 0x9c, 0xef, 0x8a, 0x26, 0x9b, 0xbf, 0x41, 0x06, 0xe6, 0x31, 0x71, 0x99, 0x7d, 0xe1, 0xec,
-	0xf9, 0xdf, 0x13, 0x9a, 0xdc, 0x83, 0x62, 0xf8, 0x1d, 0xf4, 0x23, 0x50, 0x88, 0x65, 0xc8, 0x69,
-	0x28, 0xdc, 0xc5, 0xd5, 0xd8, 0x75, 0xb6, 0x0c, 0x7f, 0x12, 0x05, 0x22, 0xdb, 0xe8, 0x2e, 0xe4,
-	0xba, 0xf6, 0x70, 0x68, 0xd2, 0x2a, 0x70, 0xeb, 0xb5, 0xd8, 0x09, 0x70, 0xad, 0x56, 0x02, 0x4b,
-	0x7d, 0xb4, 0x07, 0xe5, 0x81, 0xe9, 0x51, 0xcd, 0xb3, 0x74, 0xc7, 0xeb, 0xdb, 0xd4, 0xab, 0x16,
-	0xb9, 0x87, 0xeb, 0x71, 0x1e, 0x76, 0x4d, 0x8f, 0x1e, 0xfa, 0xca, 0xad, 0x04, 0x2e, 0x0d, 0xc2,
-	0x02, 0xe6, 0xcf, 0x3e, 0x3a, 0x22, 0x6e, 0xe0, 0xb0, 0xba, 0x74, 0xb6, 0xbf, 0x7d, 0xa6, 0xed,
-	0xdb, 0x33, 0x7f, 0x76, 0x58, 0x80, 0x7e, 0x0e, 0x17, 0x06, 0xb6, 0x6e, 0x04, 0xee, 0xb4, 0x6e,
-	0x7f, 0x64, 0x3d, 0xa9, 0x96, 0xb8, 0xd3, 0x1b, 0xb1, 0x83, 0xb4, 0x75, 0xc3, 0x77, 0xd1, 0x60,
-	0x06, 0xad, 0x04, 0x5e, 0x19, 0x4c, 0x0a, 0xd1, 0x63, 0x58, 0xd5, 0x1d, 0x67, 0x70, 0x3a, 0xe9,
-	0xbd, 0xcc, 0xbd, 0xdf, 0x8c, 0xf3, 0xbe, 0xcd, 0x6c, 0x26, 0xdd, 0x23, 0x7d, 0x4a, 0x5a, 0xcf,
-	0x43, 0xf6, 0x58, 0x1f, 0x8c, 0x88, 0xfa, 0x1d, 0x28, 0x86, 0xd2, 0x14, 0x55, 0x21, 0x3f, 0x24,
-	0x9e, 0xa7, 0xf7, 0x08, 0xcf, 0x6a, 0x05, 0xfb, 0x5d, 0xb5, 0x0c, 0x4b, 0xe1, 0xd4, 0x54, 0x9f,
-	0x27, 0x03, 0x4b, 0x96, 0x75, 0xcc, 0xf2, 0x98, 0xb8, 0x9e, 0x69, 0x5b, 0xbe, 0xa5, 0xec, 0xa2,
-	0x6b, 0x50, 0xe2, 0xfb, 0x47, 0xf3, 0xbf, 0xb3, 0xd4, 0xcf, 0xe0, 0x25, 0x2e, 0x7c, 0x24, 0x95,
-	0xd6, 0xa1, 0xe8, 0x6c, 0x39, 0x81, 0x4a, 0x9a, 0xab, 0x80, 0xb3, 0xe5, 0xf8, 0x0a, 0xaf, 0xc3,
-	0x12, 0x9b, 0x69, 0xa0, 0x91, 0xe1, 0x3f, 0x52, 0x64, 0x32, 0xa9, 0xa2, 0xfe, 0x39, 0x05, 0x95,
-	0xc9, 0x74, 0x46, 0x77, 0x21, 0xc3, 0x90, 0x4d, 0x82, 0x54, 0x6d, 0x43, 0xc0, 0xde, 0x86, 0x0f,
-	0x7b, 0x1b, 0x6d, 0x1f, 0xf6, 0xea, 0x85, 0xaf, 0xbe, 0x59, 0x4f, 0x3c, 0xff, 0xfb, 0x7a, 0x12,
-	0x73, 0x0b, 0x74, 0x89, 0x65, 0x9f, 0x6e, 0x5a, 0x9a, 0x69, 0xf0, 0x21, 0x2b, 0x2c, 0xb5, 0x74,
-	0xd3, 0xda, 0x31, 0xd0, 0x2e, 0x54, 0xba, 0xb6, 0xe5, 0x11, 0xcb, 0x1b, 0x79, 0x9a, 0x80, 0x55,
-	0x09, 0x4d, 0x91, 0x04, 0x13, 0x60, 0xdd, 0xf0, 0x35, 0x0f, 0xb8, 0x22, 0x5e, 0xee, 0x46, 0x05,
-	0xe8, 0x3e, 0xc0, 0xb1, 0x3e, 0x30, 0x0d, 0x9d, 0xda, 0xae, 0x57, 0xcd, 0x5c, 0x4d, 0xcf, 0xcc,
-	0xb2, 0x47, 0xbe, 0xca, 0x43, 0xc7, 0xd0, 0x29, 0xa9, 0x67, 0xd8, 0x70, 0x71, 0xc8, 0x12, 0xbd,
-	0x01, 0xcb, 0xba, 0xe3, 0x68, 0x1e, 0xd5, 0x29, 0xd1, 0x3a, 0xa7, 0x94, 0x78, 0x1c, 0xb6, 0x96,
-	0x70, 0x49, 0x77, 0x9c, 0x43, 0x26, 0xad, 0x33, 0x21, 0xba, 0x0e, 0x65, 0x86, 0x70, 0xa6, 0x3e,
-	0xd0, 0xfa, 0xc4, 0xec, 0xf5, 0x29, 0x07, 0xa8, 0x34, 0x2e, 0x49, 0x69, 0x8b, 0x0b, 0x55, 0x23,
-	0x58, 0x71, 0x8e, 0x6e, 0x08, 0x41, 0xc6, 0xd0, 0xa9, 0xce, 0x23, 0xb9, 0x84, 0x79, 0x9b, 0xc9,
-	0x1c, 0x9d, 0xf6, 0x65, 0x7c, 0x78, 0x1b, 0x5d, 0x84, 0x9c, 0x74, 0x9b, 0xe6, 0x6e, 0x65, 0x0f,
-	0xad, 0x42, 0xd6, 0x71, 0xed, 0x63, 0xc2, 0x97, 0xae, 0x80, 0x45, 0x47, 0xfd, 0x55, 0x0a, 0x56,
-	0xa6, 0x70, 0x90, 0xf9, 0xed, 0xeb, 0x5e, 0xdf, 0xff, 0x2d, 0xd6, 0x46, 0x77, 0x98, 0x5f, 0xdd,
-	0x20, 0xae, 0x3c, 0x3b, 0xaa, 0xd3, 0xa1, 0x6e, 0xf1, 0xef, 0x32, 0x34, 0x52, 0x1b, 0xed, 0x43,
-	0x65, 0xa0, 0x7b, 0x54, 0x13, 0xb8, 0xa2, 0x85, 0xce, 0x91, 0x69, 0x34, 0xdd, 0xd5, 0x7d, 0x24,
-	0x62, 0x9b, 0x5a, 0x3a, 0x2a, 0x0f, 0x22, 0x52, 0x84, 0x61, 0xb5, 0x73, 0xfa, 0x85, 0x6e, 0x51,
-	0xd3, 0x22, 0xda, 0xd4, 0xca, 0x5d, 0x9a, 0x72, 0xda, 0x3c, 0x36, 0x0d, 0x62, 0x75, 0xfd, 0x25,
-	0xbb, 0x10, 0x18, 0x07, 0x4b, 0xea, 0xa9, 0x18, 0xca, 0x51, 0x24, 0x47, 0x65, 0x48, 0xd1, 0x13,
-	0x19, 0x80, 0x14, 0x3d, 0x41, 0xdf, 0x85, 0x0c, 0x9b, 0x24, 0x9f, 0x7c, 0x79, 0xc6, 0x11, 0x28,
-	0xed, 0xda, 0xa7, 0x0e, 0xc1, 0x5c, 0x53, 0x55, 0x83, 0x74, 0x08, 0xd0, 0x7d, 0xd2, 0xab, 0x7a,
-	0x03, 0x96, 0x27, 0xe0, 0x3b, 0xb4, 0x7e, 0xc9, 0xf0, 0xfa, 0xa9, 0xcb, 0x50, 0x8a, 0x60, 0xb5,
-	0x7a, 0x11, 0x56, 0x67, 0x41, 0xaf, 0xda, 0x0f, 0xe4, 0x11, 0x08, 0x45, 0xb7, 0xa1, 0x10, 0x60,
-	0xaf, 0x48, 0xc7, 0xe9, 0x58, 0xf9, 0xca, 0x38, 0x50, 0x65, 0x79, 0xc8, 0xb6, 0x35, 0xdf, 0x0f,
-	0x29, 0x3e, 0xf0, 0xbc, 0xee, 0x38, 0x2d, 0xdd, 0xeb, 0xab, 0x9f, 0x42, 0x35, 0x0e, 0x57, 0x27,
-	0xa6, 0x91, 0x09, 0xb6, 0xe1, 0x45, 0xc8, 0x1d, 0xd9, 0xee, 0x50, 0xa7, 0xdc, 0x59, 0x09, 0xcb,
-	0x1e, 0xdb, 0x9e, 0x02, 0x63, 0xd3, 0x5c, 0x2c, 0x3a, 0xaa, 0x06, 0x97, 0x62, 0xb1, 0x95, 0x99,
-	0x98, 0x96, 0x41, 0x44, 0x3c, 0x4b, 0x58, 0x74, 0xc6, 0x8e, 0xc4, 0x60, 0x45, 0x87, 0xfd, 0xac,
-	0xc7, 0xe7, 0xca, 0xfd, 0x2b, 0x58, 0xf6, 0xd4, 0xdf, 0x15, 0xa0, 0x80, 0x89, 0xe7, 0x30, 0x4c,
-	0x40, 0x75, 0x50, 0xc8, 0x49, 0x97, 0x38, 0xd4, 0x87, 0xd1, 0xd9, 0xac, 0x41, 0x68, 0x37, 0x7d,
-	0x4d, 0x76, 0x64, 0x07, 0x66, 0xe8, 0x96, 0x64, 0x65, 0xf1, 0x04, 0x4b, 0x9a, 0x87, 0x69, 0xd9,
-	0x1d, 0x9f, 0x96, 0xa5, 0x63, 0x4f, 0x69, 0x61, 0x35, 0xc1, 0xcb, 0x6e, 0x49, 0x5e, 0x96, 0x99,
-	0xf3, 0x63, 0x11, 0x62, 0xd6, 0x88, 0x10, 0xb3, 0xec, 0x9c, 0x69, 0xc6, 0x30, 0xb3, 0x3b, 0x3e,
-	0x33, 0xcb, 0xcd, 0x19, 0xf1, 0x04, 0x35, 0xbb, 0x1f, 0xa5, 0x66, 0x82, 0x56, 0x5d, 0x8b, 0xb5,
-	0x8e, 0xe5, 0x66, 0x3f, 0x08, 0x71, 0xb3, 0x42, 0x2c, 0x31, 0x12, 0x4e, 0x66, 0x90, 0xb3, 0x46,
-	0x84, 0x9c, 0x29, 0x73, 0x62, 0x10, 0xc3, 0xce, 0x3e, 0x08, 0xb3, 0x33, 0x88, 0x25, 0x78, 0x72,
-	0xbd, 0x67, 0xd1, 0xb3, 0xf7, 0x02, 0x7a, 0x56, 0x8c, 0xe5, 0x97, 0x72, 0x0e, 0x93, 0xfc, 0x6c,
-	0x7f, 0x8a, 0x9f, 0x09, 0x3e, 0xf5, 0x46, 0xac, 0x8b, 0x39, 0x04, 0x6d, 0x7f, 0x8a, 0xa0, 0x95,
-	0xe6, 0x38, 0x9c, 0xc3, 0xd0, 0x7e, 0x31, 0x9b, 0xa1, 0xc5, 0x73, 0x28, 0x39, 0xcc, 0xc5, 0x28,
-	0x9a, 0x16, 0x43, 0xd1, 0x96, 0xb9, 0xfb, 0xb7, 0x62, 0xdd, 0x9f, 0x9f, 0xa3, 0xdd, 0x60, 0x27,
-	0xe4, 0x44, 0xce, 0x33, 0x94, 0x21, 0xae, 0x6b, 0xbb, 0x92, 0x6d, 0x89, 0x8e, 0xfa, 0x26, 0x3b,
-	0xb3, 0xc7, 0xf9, 0x7d, 0x06, 0x9f, 0xe3, 0x68, 0x1e, 0xca, 0x69, 0xf5, 0x0f, 0xc9, 0xb1, 0x2d,
-	0x3f, 0xe6, 0xc2, 0xe7, 0xbd, 0x22, 0xcf, 0xfb, 0x10, 0xcb, 0x4b, 0x45, 0x59, 0xde, 0x3a, 0x14,
-	0x19, 0x4a, 0x4f, 0x10, 0x38, 0xdd, 0x09, 0x08, 0xdc, 0x4d, 0x58, 0xe1, 0xc7, 0xb0, 0xe0, 0x82,
-	0x12, 0x9a, 0x33, 0xfc, 0x84, 0x59, 0x66, 0x1f, 0xc4, 0xe6, 0x14, 0x18, 0xfd, 0x0e, 0x5c, 0x08,
-	0xe9, 0x06, 0xe8, 0x2f, 0xd8, 0x4c, 0x25, 0xd0, 0xde, 0x96, 0xc7, 0xc0, 0x9f, 0x92, 0xe3, 0x08,
-	0x8d, 0x99, 0xdf, 0x2c, 0x92, 0x96, 0xfc, 0x1f, 0x91, 0xb4, 0xd4, 0x7f, 0x4d, 0xd2, 0xc2, 0xa7,
-	0x59, 0x3a, 0x7a, 0x9a, 0xfd, 0x2b, 0x39, 0x5e, 0x93, 0x80, 0x72, 0x75, 0x6d, 0x83, 0xc8, 0xf3,
-	0x85, 0xb7, 0x51, 0x05, 0xd2, 0x03, 0xbb, 0x27, 0x4f, 0x11, 0xd6, 0x64, 0x5a, 0x01, 0x08, 0x2b,
-	0x12, 0x63, 0x83, 0xa3, 0x29, 0xcb, 0x23, 0x2c, 0x8f, 0xa6, 0x0a, 0xa4, 0x9f, 0x10, 0x01, 0x99,
-	0x4b, 0x98, 0x35, 0x99, 0x1e, 0xdf, 0x64, 0x1c, 0x08, 0x97, 0xb0, 0xe8, 0xa0, 0xbb, 0xa0, 0xf0,
-	0x32, 0x84, 0x66, 0x3b, 0x9e, 0x44, 0xb7, 0xd7, 0xc2, 0x73, 0x15, 0xd5, 0x86, 0x8d, 0x03, 0xa6,
-	0xb3, 0xef, 0x78, 0xb8, 0xe0, 0xc8, 0x56, 0xe8, 0xd4, 0x55, 0x22, 0xe4, 0xef, 0x32, 0x28, 0x6c,
-	0xf4, 0x9e, 0xa3, 0x77, 0x09, 0x87, 0x2a, 0x05, 0x8f, 0x05, 0xea, 0x63, 0x40, 0xd3, 0x80, 0x8b,
-	0x5a, 0x90, 0x23, 0xc7, 0xc4, 0xa2, 0x6c, 0xd9, 0x58, 0xb8, 0x2f, 0xce, 0x60, 0x56, 0xc4, 0xa2,
-	0xf5, 0x2a, 0x0b, 0xf2, 0x3f, 0xbf, 0x59, 0xaf, 0x08, 0xed, 0xb7, 0xed, 0xa1, 0x49, 0xc9, 0xd0,
-	0xa1, 0xa7, 0x58, 0xda, 0xab, 0x7f, 0x4b, 0x31, 0x9a, 0x13, 0x01, 0xe3, 0x99, 0xb1, 0xf5, 0xb7,
-	0x7c, 0x2a, 0x44, 0x71, 0x17, 0x8b, 0xf7, 0x1a, 0x40, 0x4f, 0xf7, 0xb4, 0xa7, 0xba, 0x45, 0x89,
-	0x21, 0x83, 0x1e, 0x92, 0xa0, 0x1a, 0x14, 0x58, 0x6f, 0xe4, 0x11, 0x43, 0xb2, 0xed, 0xa0, 0x1f,
-	0x9a, 0x67, 0xfe, 0xdb, 0xcd, 0x33, 0x1a, 0xe5, 0xc2, 0x44, 0x94, 0x43, 0x14, 0x44, 0x09, 0x53,
-	0x10, 0x36, 0x36, 0xc7, 0x35, 0x6d, 0xd7, 0xa4, 0xa7, 0x7c, 0x69, 0xd2, 0x38, 0xe8, 0xb3, 0xcb,
-	0xdb, 0x90, 0x0c, 0x1d, 0xdb, 0x1e, 0x68, 0x02, 0x6e, 0x8a, 0xdc, 0x74, 0x49, 0x0a, 0x9b, 0x1c,
-	0x75, 0x7e, 0x9d, 0x1a, 0xe7, 0xdf, 0x98, 0x6a, 0xfe, 0xdf, 0x05, 0x58, 0xfd, 0x0d, 0xbf, 0x80,
-	0x46, 0x8f, 0x5b, 0x74, 0x08, 0x2b, 0x41, 0xfa, 0x6b, 0x23, 0x0e, 0x0b, 0xfe, 0x86, 0x5e, 0x14,
-	0x3f, 0x2a, 0xc7, 0x51, 0xb1, 0x87, 0x3e, 0x86, 0x57, 0x27, 0xb0, 0x2d, 0x70, 0x9d, 0x5a, 0x14,
-	0xe2, 0x5e, 0x89, 0x42, 0x9c, 0xef, 0x7a, 0x1c, 0xac, 0xf4, 0xb7, 0xcc, 0xba, 0x1d, 0x76, 0xa7,
-	0x09, 0xb3, 0x87, 0x99, 0xcb, 0x7f, 0x0d, 0x4a, 0x2e, 0xa1, 0xec, 0x9e, 0x1d, 0xb9, 0x35, 0x2e,
-	0x09, 0xa1, 0xbc, 0x8b, 0x1e, 0xc0, 0x2b, 0x33, 0x59, 0x04, 0xfa, 0x1e, 0x28, 0x63, 0x02, 0x92,
-	0x8c, 0xb9, 0x80, 0x05, 0x97, 0x8a, 0xb1, 0xae, 0xfa, 0xc7, 0xe4, 0xd8, 0x65, 0xf4, 0x9a, 0xd2,
-	0x84, 0x9c, 0x4b, 0xbc, 0xd1, 0x40, 0x5c, 0x1c, 0xca, 0x5b, 0xef, 0x2c, 0xc6, 0x3f, 0x98, 0x74,
-	0x34, 0xa0, 0x58, 0x1a, 0xab, 0x8f, 0x21, 0x27, 0x24, 0xa8, 0x08, 0xf9, 0x87, 0x7b, 0x0f, 0xf6,
-	0xf6, 0x3f, 0xda, 0xab, 0x24, 0x10, 0x40, 0x6e, 0xbb, 0xd1, 0x68, 0x1e, 0xb4, 0x2b, 0x49, 0xa4,
-	0x40, 0x76, 0xbb, 0xbe, 0x8f, 0xdb, 0x95, 0x14, 0x13, 0xe3, 0xe6, 0x87, 0xcd, 0x46, 0xbb, 0x92,
-	0x46, 0x2b, 0x50, 0x12, 0x6d, 0xed, 0xfe, 0x3e, 0xfe, 0xc9, 0x76, 0xbb, 0x92, 0x09, 0x89, 0x0e,
-	0x9b, 0x7b, 0xf7, 0x9a, 0xb8, 0x92, 0x55, 0xdf, 0x65, 0x37, 0x93, 0x18, 0xc6, 0x32, 0xbe, 0x83,
-	0x24, 0x43, 0x77, 0x10, 0xf5, 0xb7, 0x29, 0xa8, 0xc5, 0xd3, 0x10, 0xf4, 0xe1, 0xc4, 0xc4, 0xb7,
-	0xce, 0xc1, 0x61, 0x26, 0x66, 0x8f, 0xae, 0x43, 0xd9, 0x25, 0x47, 0x84, 0x76, 0xfb, 0x82, 0x16,
-	0x89, 0x23, 0xb3, 0x84, 0x4b, 0x52, 0xca, 0x8d, 0x3c, 0xa1, 0xf6, 0x19, 0xe9, 0x52, 0x4d, 0x60,
-	0x91, 0xd8, 0x74, 0x0a, 0x53, 0x63, 0xd2, 0x43, 0x21, 0x54, 0x3f, 0x3d, 0x57, 0x2c, 0x15, 0xc8,
-	0xe2, 0x66, 0x1b, 0x7f, 0x5c, 0x49, 0x23, 0x04, 0x65, 0xde, 0xd4, 0x0e, 0xf7, 0xb6, 0x0f, 0x0e,
-	0x5b, 0xfb, 0x2c, 0x96, 0x17, 0x60, 0xd9, 0x8f, 0xa5, 0x2f, 0xcc, 0xaa, 0x9f, 0x40, 0x39, 0x7a,
-	0xf7, 0x67, 0x21, 0x74, 0xed, 0x91, 0x65, 0xf0, 0x60, 0x64, 0xb1, 0xe8, 0xa0, 0xdb, 0x90, 0x3d,
-	0xb6, 0x45, 0x9a, 0xcd, 0xde, 0x6b, 0x8f, 0x6c, 0x4a, 0x42, 0xb5, 0x03, 0xa1, 0xad, 0x7e, 0x01,
-	0x59, 0x9e, 0x35, 0x2c, 0x03, 0xf8, 0x2d, 0x5e, 0x92, 0x2a, 0xd6, 0x46, 0x9f, 0x00, 0xe8, 0x94,
-	0xba, 0x66, 0x67, 0x34, 0x76, 0xbc, 0x3e, 0x3b, 0xeb, 0xb6, 0x7d, 0xbd, 0xfa, 0x65, 0x99, 0x7e,
-	0xab, 0x63, 0xd3, 0x50, 0x0a, 0x86, 0x1c, 0xaa, 0x7b, 0x50, 0x8e, 0xda, 0xfa, 0x34, 0x40, 0x8c,
-	0x21, 0x4a, 0x03, 0x04, 0xab, 0x93, 0x34, 0x20, 0x20, 0x11, 0x69, 0x51, 0xb1, 0xe1, 0x1d, 0xf5,
-	0x59, 0x12, 0x0a, 0xed, 0x13, 0xb9, 0x1e, 0x31, 0xc5, 0x82, 0xb1, 0x69, 0x2a, 0x7c, 0x35, 0x16,
-	0xd5, 0x87, 0x74, 0x50, 0xd3, 0xf8, 0x20, 0xd8, 0x71, 0x99, 0x45, 0x6f, 0x40, 0x7e, 0x71, 0x47,
-	0x66, 0xd9, 0xfb, 0xa0, 0x04, 0x98, 0xc9, 0xd8, 0xa9, 0x6e, 0x18, 0x2e, 0xf1, 0x3c, 0xb9, 0xef,
-	0xfd, 0x2e, 0xaf, 0x3d, 0xd9, 0x4f, 0xe5, 0xe5, 0x3b, 0x8d, 0x45, 0x47, 0x35, 0x60, 0x79, 0x02,
-	0x70, 0xd1, 0xfb, 0x90, 0x77, 0x46, 0x1d, 0xcd, 0x0f, 0xcf, 0xc4, 0x5b, 0x83, 0xcf, 0x7b, 0x46,
-	0x9d, 0x81, 0xd9, 0x7d, 0x40, 0x4e, 0xfd, 0xc1, 0x38, 0xa3, 0xce, 0x03, 0x11, 0x45, 0xf1, 0x2b,
-	0xa9, 0xf0, 0xaf, 0x1c, 0x43, 0xc1, 0xdf, 0x14, 0xe8, 0x87, 0xa0, 0x04, 0x58, 0x1e, 0x94, 0x24,
-	0x63, 0x0f, 0x01, 0xe9, 0x7e, 0x6c, 0xc2, 0x48, 0xb4, 0x67, 0xf6, 0x2c, 0x62, 0x68, 0x63, 0x7e,
-	0xcc, 0x7f, 0xad, 0x80, 0x97, 0xc5, 0x87, 0x5d, 0x9f, 0x1c, 0xab, 0xff, 0x4e, 0x42, 0xc1, 0x2f,
-	0x3d, 0xa1, 0x77, 0x43, 0xfb, 0xae, 0x3c, 0xe3, 0xa2, 0xee, 0x2b, 0x8e, 0xcb, 0x47, 0xd1, 0xb1,
-	0xa6, 0xce, 0x3f, 0xd6, 0xb8, 0x3a, 0xa0, 0x5f, 0x91, 0xcd, 0x9c, 0xbb, 0x22, 0xfb, 0x36, 0x20,
-	0x6a, 0x53, 0x7d, 0xa0, 0x1d, 0xdb, 0xd4, 0xb4, 0x7a, 0x9a, 0x08, 0xb6, 0xe0, 0x02, 0x15, 0xfe,
-	0xe5, 0x11, 0xff, 0x70, 0xc0, 0xe3, 0xfe, 0xcb, 0x24, 0x14, 0x02, 0x50, 0x3f, 0x6f, 0x35, 0xe8,
-	0x22, 0xe4, 0x24, 0x6e, 0x89, 0x72, 0x90, 0xec, 0x05, 0x85, 0xc9, 0x4c, 0xa8, 0x30, 0x59, 0x83,
-	0xc2, 0x90, 0x50, 0x9d, 0x9f, 0x6c, 0xe2, 0x8a, 0x12, 0xf4, 0x6f, 0xbe, 0x07, 0xc5, 0x50, 0x61,
-	0x8e, 0x65, 0xde, 0x5e, 0xf3, 0xa3, 0x4a, 0xa2, 0x96, 0x7f, 0xf6, 0xe5, 0xd5, 0xf4, 0x1e, 0x79,
-	0xca, 0xf6, 0x2c, 0x6e, 0x36, 0x5a, 0xcd, 0xc6, 0x83, 0x4a, 0xb2, 0x56, 0x7c, 0xf6, 0xe5, 0xd5,
-	0x3c, 0x26, 0xbc, 0x48, 0x70, 0xb3, 0x05, 0x4b, 0xe1, 0x55, 0x89, 0x42, 0x1f, 0x82, 0xf2, 0xbd,
-	0x87, 0x07, 0xbb, 0x3b, 0x8d, 0xed, 0x76, 0x53, 0x7b, 0xb4, 0xdf, 0x6e, 0x56, 0x92, 0xe8, 0x55,
-	0xb8, 0xb0, 0xbb, 0xf3, 0xe3, 0x56, 0x5b, 0x6b, 0xec, 0xee, 0x34, 0xf7, 0xda, 0xda, 0x76, 0xbb,
-	0xbd, 0xdd, 0x78, 0x50, 0x49, 0x6d, 0xfd, 0x5e, 0x81, 0xe5, 0xed, 0x7a, 0x63, 0x87, 0xc1, 0xb6,
-	0xd9, 0xd5, 0xf9, 0xfd, 0xb1, 0x01, 0x19, 0x7e, 0x43, 0x3c, 0xf3, 0xd9, 0xae, 0x76, 0x76, 0xf9,
-	0x08, 0xdd, 0x87, 0x2c, 0xbf, 0x3c, 0xa2, 0xb3, 0xdf, 0xf1, 0x6a, 0x73, 0xea, 0x49, 0x6c, 0x30,
-	0x3c, 0x3d, 0xce, 0x7c, 0xd8, 0xab, 0x9d, 0x5d, 0x5e, 0x42, 0x18, 0x94, 0x31, 0xf9, 0x9c, 0xff,
-	0xd0, 0x55, 0x5b, 0x00, 0x6c, 0xd0, 0x2e, 0xe4, 0xfd, 0xfb, 0xc2, 0xbc, 0xa7, 0xb7, 0xda, 0xdc,
-	0xfa, 0x0f, 0x0b, 0x97, 0xb8, 0xd7, 0x9d, 0xfd, 0x8e, 0x58, 0x9b, 0x53, 0xcc, 0x42, 0x3b, 0x90,
-	0x93, 0x84, 0x6a, 0xce, 0x73, 0x5a, 0x6d, 0x5e, 0x3d, 0x87, 0x05, 0x6d, 0x7c, 0x63, 0x9e, 0xff,
-	0x3a, 0x5a, 0x5b, 0xa0, 0x4e, 0x87, 0x1e, 0x02, 0x84, 0x6e, 0x71, 0x0b, 0x3c, 0x7b, 0xd6, 0x16,
-	0xa9, 0xbf, 0xa1, 0x7d, 0x28, 0x04, 0xa4, 0x7a, 0xee, 0x23, 0x64, 0x6d, 0x7e, 0x21, 0x0c, 0x3d,
-	0x86, 0x52, 0x94, 0x4c, 0x2e, 0xf6, 0xb4, 0x58, 0x5b, 0xb0, 0xc2, 0xc5, 0xfc, 0x47, 0x99, 0xe5,
-	0x62, 0x4f, 0x8d, 0xb5, 0x05, 0x0b, 0x5e, 0xe8, 0x33, 0x58, 0x99, 0x66, 0x7e, 0x8b, 0xbf, 0x3c,
-	0xd6, 0xce, 0x51, 0x02, 0x43, 0x43, 0x40, 0x33, 0x18, 0xe3, 0x39, 0x1e, 0x22, 0x6b, 0xe7, 0xa9,
-	0x88, 0xd5, 0x9b, 0x5f, 0xbd, 0x58, 0x4b, 0x7e, 0xfd, 0x62, 0x2d, 0xf9, 0x8f, 0x17, 0x6b, 0xc9,
-	0xe7, 0x2f, 0xd7, 0x12, 0x5f, 0xbf, 0x5c, 0x4b, 0xfc, 0xf5, 0xe5, 0x5a, 0xe2, 0x67, 0x6f, 0xf5,
-	0x4c, 0xda, 0x1f, 0x75, 0x36, 0xba, 0xf6, 0x70, 0x33, 0xfc, 0x0f, 0x87, 0x59, 0xff, 0xba, 0xe8,
-	0xe4, 0xf8, 0xa1, 0x72, 0xeb, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x92, 0xa5, 0x39, 0xcc, 0x95,
-	0x21, 0x00, 0x00,
+	// 2585 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4b, 0x73, 0x1b, 0xc7,
+	0x11, 0xc6, 0x1b, 0xd8, 0x26, 0x01, 0x82, 0x23, 0x5a, 0x86, 0x60, 0x89, 0x94, 0x57, 0x25, 0xc7,
+	0x92, 0x6d, 0x32, 0xa6, 0x4a, 0x8a, 0x5c, 0xce, 0xc3, 0x04, 0x04, 0x05, 0xb4, 0x18, 0x92, 0x19,
+	0x42, 0x72, 0x39, 0x89, 0xb5, 0x5e, 0x60, 0x87, 0xc0, 0x5a, 0xc0, 0xee, 0x1a, 0x3b, 0xa0, 0x48,
+	0x1f, 0xf3, 0xb8, 0xa8, 0x72, 0xd0, 0x31, 0x17, 0x57, 0xe5, 0x1f, 0xe4, 0x9a, 0x53, 0x4e, 0x39,
+	0xf8, 0x90, 0x54, 0xf9, 0x98, 0x93, 0x93, 0x92, 0x6e, 0xf9, 0x03, 0x39, 0xa5, 0x2a, 0x35, 0x8f,
+	0x7d, 0x01, 0x58, 0x00, 0x8c, 0x73, 0xcb, 0x6d, 0xa6, 0xb7, 0xbb, 0x31, 0xd3, 0x33, 0xdd, 0xfd,
+	0x75, 0x0f, 0xe0, 0x35, 0x4a, 0x2c, 0x83, 0x0c, 0x07, 0xa6, 0x45, 0xb7, 0xf4, 0x76, 0xc7, 0xdc,
+	0xa2, 0x67, 0x0e, 0x71, 0x37, 0x9d, 0xa1, 0x4d, 0x6d, 0xb4, 0x12, 0x7c, 0xdc, 0x64, 0x1f, 0xab,
+	0x57, 0x42, 0xdc, 0x9d, 0xe1, 0x99, 0x43, 0xed, 0x2d, 0x67, 0x68, 0xdb, 0xc7, 0x82, 0xbf, 0x7a,
+	0x39, 0xf4, 0x99, 0xeb, 0x09, 0x6b, 0x8b, 0x7c, 0x95, 0xc2, 0x4f, 0xc8, 0x99, 0xf7, 0xf5, 0xca,
+	0x84, 0xac, 0xa3, 0x0f, 0xf5, 0x81, 0xf7, 0x79, 0xa3, 0x6b, 0xdb, 0xdd, 0x3e, 0xd9, 0xe2, 0xb3,
+	0xf6, 0xe8, 0x78, 0x8b, 0x9a, 0x03, 0xe2, 0x52, 0x7d, 0xe0, 0x48, 0x86, 0xb5, 0xae, 0xdd, 0xb5,
+	0xf9, 0x70, 0x8b, 0x8d, 0x04, 0x55, 0xfd, 0x6b, 0x1e, 0xf2, 0x98, 0x7c, 0x3e, 0x22, 0x2e, 0x45,
+	0xdb, 0x90, 0x21, 0x9d, 0x9e, 0x5d, 0x49, 0x5e, 0x4d, 0xbe, 0xb9, 0xb4, 0x7d, 0x79, 0x73, 0x6c,
+	0x73, 0x9b, 0x92, 0xaf, 0xd1, 0xe9, 0xd9, 0xcd, 0x04, 0xe6, 0xbc, 0xe8, 0x36, 0x64, 0x8f, 0xfb,
+	0x23, 0xb7, 0x57, 0x49, 0x71, 0xa1, 0x2b, 0x71, 0x42, 0xf7, 0x19, 0x53, 0x33, 0x81, 0x05, 0x37,
+	0xfb, 0x29, 0xd3, 0x3a, 0xb6, 0x2b, 0xe9, 0xd9, 0x3f, 0xb5, 0x6b, 0x1d, 0xf3, 0x9f, 0x62, 0xbc,
+	0xa8, 0x06, 0x60, 0x5a, 0x26, 0xd5, 0x3a, 0x3d, 0xdd, 0xb4, 0x2a, 0x19, 0x2e, 0xf9, 0x7a, 0xbc,
+	0xa4, 0x49, 0xeb, 0x8c, 0xb1, 0x99, 0xc0, 0x8a, 0xe9, 0x4d, 0xd8, 0x72, 0x3f, 0x1f, 0x91, 0xe1,
+	0x59, 0x25, 0x3b, 0x7b, 0xb9, 0x3f, 0x65, 0x4c, 0x6c, 0xb9, 0x9c, 0x1b, 0x35, 0x60, 0xa9, 0x4d,
+	0xba, 0xa6, 0xa5, 0xb5, 0xfb, 0x76, 0xe7, 0x49, 0x25, 0xc7, 0x85, 0xd5, 0x38, 0xe1, 0x1a, 0x63,
+	0xad, 0x31, 0xce, 0x66, 0x02, 0x43, 0xdb, 0x9f, 0xa1, 0xef, 0x43, 0xa1, 0xd3, 0x23, 0x9d, 0x27,
+	0x1a, 0x3d, 0xad, 0xe4, 0xb9, 0x8e, 0x8d, 0x38, 0x1d, 0x75, 0xc6, 0xd7, 0x3a, 0x6d, 0x26, 0x70,
+	0xbe, 0x23, 0x86, 0x6c, 0xff, 0x06, 0xe9, 0x9b, 0x27, 0x64, 0xc8, 0xe4, 0x0b, 0xb3, 0xf7, 0x7f,
+	0x4f, 0x70, 0x72, 0x0d, 0x8a, 0xe1, 0x4d, 0xd0, 0x8f, 0x40, 0x21, 0x96, 0x21, 0xb7, 0xa1, 0x70,
+	0x15, 0x57, 0x63, 0xcf, 0xd9, 0x32, 0xbc, 0x4d, 0x14, 0x88, 0x1c, 0xa3, 0xbb, 0x90, 0xeb, 0xd8,
+	0x83, 0x81, 0x49, 0x2b, 0xc0, 0xa5, 0xd7, 0x63, 0x37, 0xc0, 0xb9, 0x9a, 0x09, 0x2c, 0xf9, 0xd1,
+	0x3e, 0x94, 0xfa, 0xa6, 0x4b, 0x35, 0xd7, 0xd2, 0x1d, 0xb7, 0x67, 0x53, 0xb7, 0xb2, 0xc4, 0x35,
+	0x5c, 0x8f, 0xd3, 0xb0, 0x67, 0xba, 0xf4, 0xc8, 0x63, 0x6e, 0x26, 0x70, 0xb1, 0x1f, 0x26, 0x30,
+	0x7d, 0xf6, 0xf1, 0x31, 0x19, 0xfa, 0x0a, 0x2b, 0xcb, 0xb3, 0xf5, 0x1d, 0x30, 0x6e, 0x4f, 0x9e,
+	0xe9, 0xb3, 0xc3, 0x04, 0xf4, 0x73, 0xb8, 0xd0, 0xb7, 0x75, 0xc3, 0x57, 0xa7, 0x75, 0x7a, 0x23,
+	0xeb, 0x49, 0xa5, 0xc8, 0x95, 0xde, 0x88, 0x5d, 0xa4, 0xad, 0x1b, 0x9e, 0x8a, 0x3a, 0x13, 0x68,
+	0x26, 0xf0, 0x6a, 0x7f, 0x9c, 0x88, 0x1e, 0xc3, 0x9a, 0xee, 0x38, 0xfd, 0xb3, 0x71, 0xed, 0x25,
+	0xae, 0xfd, 0x66, 0x9c, 0xf6, 0x1d, 0x26, 0x33, 0xae, 0x1e, 0xe9, 0x13, 0xd4, 0x5a, 0x1e, 0xb2,
+	0x27, 0x7a, 0x7f, 0x44, 0xd4, 0xef, 0xc0, 0x52, 0xc8, 0x4d, 0x51, 0x05, 0xf2, 0x03, 0xe2, 0xba,
+	0x7a, 0x97, 0x70, 0xaf, 0x56, 0xb0, 0x37, 0x55, 0x4b, 0xb0, 0x1c, 0x76, 0x4d, 0xf5, 0x79, 0xd2,
+	0x97, 0x64, 0x5e, 0xc7, 0x24, 0x4f, 0xc8, 0xd0, 0x35, 0x6d, 0xcb, 0x93, 0x94, 0x53, 0x74, 0x0d,
+	0x8a, 0xfc, 0xfe, 0x68, 0xde, 0x77, 0xe6, 0xfa, 0x19, 0xbc, 0xcc, 0x89, 0x8f, 0x24, 0xd3, 0x06,
+	0x2c, 0x39, 0xdb, 0x8e, 0xcf, 0x92, 0xe6, 0x2c, 0xe0, 0x6c, 0x3b, 0x1e, 0xc3, 0xeb, 0xb0, 0xcc,
+	0x76, 0xea, 0x73, 0x64, 0xf8, 0x8f, 0x2c, 0x31, 0x9a, 0x64, 0x51, 0xff, 0x92, 0x82, 0xf2, 0xb8,
+	0x3b, 0xa3, 0xbb, 0x90, 0x61, 0x91, 0x4d, 0x06, 0xa9, 0xea, 0xa6, 0x08, 0x7b, 0x9b, 0x5e, 0xd8,
+	0xdb, 0x6c, 0x79, 0x61, 0xaf, 0x56, 0xf8, 0xea, 0x9b, 0x8d, 0xc4, 0xf3, 0xbf, 0x6f, 0x24, 0x31,
+	0x97, 0x40, 0x97, 0x98, 0xf7, 0xe9, 0xa6, 0xa5, 0x99, 0x06, 0x5f, 0xb2, 0xc2, 0x5c, 0x4b, 0x37,
+	0xad, 0x5d, 0x03, 0xed, 0x41, 0xb9, 0x63, 0x5b, 0x2e, 0xb1, 0xdc, 0x91, 0xab, 0x89, 0xb0, 0x2a,
+	0x43, 0x53, 0xc4, 0xc1, 0x44, 0xb0, 0xae, 0x7b, 0x9c, 0x87, 0x9c, 0x11, 0xaf, 0x74, 0xa2, 0x04,
+	0x74, 0x1f, 0xe0, 0x44, 0xef, 0x9b, 0x86, 0x4e, 0xed, 0xa1, 0x5b, 0xc9, 0x5c, 0x4d, 0x4f, 0xf5,
+	0xb2, 0x47, 0x1e, 0xcb, 0x43, 0xc7, 0xd0, 0x29, 0xa9, 0x65, 0xd8, 0x72, 0x71, 0x48, 0x12, 0xbd,
+	0x01, 0x2b, 0xba, 0xe3, 0x68, 0x2e, 0xd5, 0x29, 0xd1, 0xda, 0x67, 0x94, 0xb8, 0x3c, 0x6c, 0x2d,
+	0xe3, 0xa2, 0xee, 0x38, 0x47, 0x8c, 0x5a, 0x63, 0x44, 0x74, 0x1d, 0x4a, 0x2c, 0xc2, 0x99, 0x7a,
+	0x5f, 0xeb, 0x11, 0xb3, 0xdb, 0xa3, 0x3c, 0x40, 0xa5, 0x71, 0x51, 0x52, 0x9b, 0x9c, 0xa8, 0x1a,
+	0xfe, 0x89, 0xf3, 0xe8, 0x86, 0x10, 0x64, 0x0c, 0x9d, 0xea, 0xdc, 0x92, 0xcb, 0x98, 0x8f, 0x19,
+	0xcd, 0xd1, 0x69, 0x4f, 0xda, 0x87, 0x8f, 0xd1, 0x45, 0xc8, 0x49, 0xb5, 0x69, 0xae, 0x56, 0xce,
+	0xd0, 0x1a, 0x64, 0x9d, 0xa1, 0x7d, 0x42, 0xf8, 0xd1, 0x15, 0xb0, 0x98, 0xa8, 0xbf, 0x4e, 0xc1,
+	0xea, 0x44, 0x1c, 0x64, 0x7a, 0x7b, 0xba, 0xdb, 0xf3, 0x7e, 0x8b, 0x8d, 0xd1, 0x1d, 0xa6, 0x57,
+	0x37, 0xc8, 0x50, 0xe6, 0x8e, 0xca, 0xa4, 0xa9, 0x9b, 0xfc, 0xbb, 0x34, 0x8d, 0xe4, 0x46, 0x07,
+	0x50, 0xee, 0xeb, 0x2e, 0xd5, 0x44, 0x5c, 0xd1, 0x42, 0x79, 0x64, 0x32, 0x9a, 0xee, 0xe9, 0x5e,
+	0x24, 0x62, 0x97, 0x5a, 0x2a, 0x2a, 0xf5, 0x23, 0x54, 0x84, 0x61, 0xad, 0x7d, 0xf6, 0x85, 0x6e,
+	0x51, 0xd3, 0x22, 0xda, 0xc4, 0xc9, 0x5d, 0x9a, 0x50, 0xda, 0x38, 0x31, 0x0d, 0x62, 0x75, 0xbc,
+	0x23, 0xbb, 0xe0, 0x0b, 0xfb, 0x47, 0xea, 0xaa, 0x18, 0x4a, 0xd1, 0x48, 0x8e, 0x4a, 0x90, 0xa2,
+	0xa7, 0xd2, 0x00, 0x29, 0x7a, 0x8a, 0xbe, 0x0b, 0x19, 0xb6, 0x49, 0xbe, 0xf9, 0xd2, 0x94, 0x14,
+	0x28, 0xe5, 0x5a, 0x67, 0x0e, 0xc1, 0x9c, 0x53, 0x55, 0x7d, 0x77, 0xf0, 0xa3, 0xfb, 0xb8, 0x56,
+	0xf5, 0x06, 0xac, 0x8c, 0x85, 0xef, 0xd0, 0xf9, 0x25, 0xc3, 0xe7, 0xa7, 0xae, 0x40, 0x31, 0x12,
+	0xab, 0xd5, 0x8b, 0xb0, 0x36, 0x2d, 0xf4, 0xaa, 0x3d, 0x9f, 0x1e, 0x09, 0xa1, 0xe8, 0x36, 0x14,
+	0xfc, 0xd8, 0x2b, 0xdc, 0x71, 0xd2, 0x56, 0x1e, 0x33, 0xf6, 0x59, 0x99, 0x1f, 0xb2, 0x6b, 0xcd,
+	0xef, 0x43, 0x8a, 0x2f, 0x3c, 0xaf, 0x3b, 0x4e, 0x53, 0x77, 0x7b, 0xea, 0xa7, 0x50, 0x89, 0x8b,
+	0xab, 0x63, 0xdb, 0xc8, 0xf8, 0xd7, 0xf0, 0x22, 0xe4, 0x8e, 0xed, 0xe1, 0x40, 0xa7, 0x5c, 0x59,
+	0x11, 0xcb, 0x19, 0xbb, 0x9e, 0x22, 0xc6, 0xa6, 0x39, 0x59, 0x4c, 0x54, 0x0d, 0x2e, 0xc5, 0xc6,
+	0x56, 0x26, 0x62, 0x5a, 0x06, 0x11, 0xf6, 0x2c, 0x62, 0x31, 0x09, 0x14, 0x89, 0xc5, 0x8a, 0x09,
+	0xfb, 0x59, 0x97, 0xef, 0x95, 0xeb, 0x57, 0xb0, 0x9c, 0xa9, 0xbf, 0x2f, 0x40, 0x01, 0x13, 0xd7,
+	0x61, 0x31, 0x01, 0xd5, 0x40, 0x21, 0xa7, 0x1d, 0xe2, 0x50, 0x2f, 0x8c, 0x4e, 0x47, 0x0d, 0x82,
+	0xbb, 0xe1, 0x71, 0xb2, 0x94, 0xed, 0x8b, 0xa1, 0x5b, 0x12, 0x95, 0xc5, 0x03, 0x2c, 0x29, 0x1e,
+	0x86, 0x65, 0x77, 0x3c, 0x58, 0x96, 0x8e, 0xcd, 0xd2, 0x42, 0x6a, 0x0c, 0x97, 0xdd, 0x92, 0xb8,
+	0x2c, 0x33, 0xe7, 0xc7, 0x22, 0xc0, 0xac, 0x1e, 0x01, 0x66, 0xd9, 0x39, 0xdb, 0x8c, 0x41, 0x66,
+	0x77, 0x3c, 0x64, 0x96, 0x9b, 0xb3, 0xe2, 0x31, 0x68, 0x76, 0x3f, 0x0a, 0xcd, 0x04, 0xac, 0xba,
+	0x16, 0x2b, 0x1d, 0x8b, 0xcd, 0x7e, 0x10, 0xc2, 0x66, 0x85, 0x58, 0x60, 0x24, 0x94, 0x4c, 0x01,
+	0x67, 0xf5, 0x08, 0x38, 0x53, 0xe6, 0xd8, 0x20, 0x06, 0x9d, 0x7d, 0x10, 0x46, 0x67, 0x10, 0x0b,
+	0xf0, 0xe4, 0x79, 0x4f, 0x83, 0x67, 0xef, 0xf9, 0xf0, 0x6c, 0x29, 0x16, 0x5f, 0xca, 0x3d, 0x8c,
+	0xe3, 0xb3, 0x83, 0x09, 0x7c, 0x26, 0xf0, 0xd4, 0x1b, 0xb1, 0x2a, 0xe6, 0x00, 0xb4, 0x83, 0x09,
+	0x80, 0x56, 0x9c, 0xa3, 0x70, 0x0e, 0x42, 0xfb, 0xc5, 0x74, 0x84, 0x16, 0x8f, 0xa1, 0xe4, 0x32,
+	0x17, 0x83, 0x68, 0x5a, 0x0c, 0x44, 0x5b, 0xe1, 0xea, 0xdf, 0x8a, 0x55, 0x7f, 0x7e, 0x8c, 0x76,
+	0x83, 0x65, 0xc8, 0x31, 0x9f, 0x67, 0x51, 0x86, 0x0c, 0x87, 0xf6, 0x50, 0xa2, 0x2d, 0x31, 0x51,
+	0xdf, 0x64, 0x39, 0x3b, 0xf0, 0xef, 0x19, 0x78, 0x8e, 0x47, 0xf3, 0x90, 0x4f, 0xab, 0x7f, 0x4c,
+	0x06, 0xb2, 0x3c, 0xcd, 0x85, 0xf3, 0xbd, 0x22, 0xf3, 0x7d, 0x08, 0xe5, 0xa5, 0xa2, 0x28, 0x6f,
+	0x03, 0x96, 0x58, 0x94, 0x1e, 0x03, 0x70, 0xba, 0xe3, 0x03, 0xb8, 0x9b, 0xb0, 0xca, 0xd3, 0xb0,
+	0xc0, 0x82, 0x32, 0x34, 0x67, 0x78, 0x86, 0x59, 0x61, 0x1f, 0xc4, 0xe5, 0x14, 0x31, 0xfa, 0x1d,
+	0xb8, 0x10, 0xe2, 0xf5, 0xa3, 0xbf, 0x40, 0x33, 0x65, 0x9f, 0x7b, 0x47, 0xa6, 0x81, 0x3f, 0x27,
+	0x03, 0x0b, 0x05, 0xc8, 0x6f, 0x1a, 0x48, 0x4b, 0xfe, 0x8f, 0x40, 0x5a, 0xea, 0xbf, 0x06, 0x69,
+	0xe1, 0x6c, 0x96, 0x8e, 0x66, 0xb3, 0x7f, 0x25, 0x83, 0x33, 0xf1, 0x21, 0x57, 0xc7, 0x36, 0x88,
+	0xcc, 0x2f, 0x7c, 0x8c, 0xca, 0x90, 0xee, 0xdb, 0x5d, 0x99, 0x45, 0xd8, 0x90, 0x71, 0xf9, 0x41,
+	0x58, 0x91, 0x31, 0xd6, 0x4f, 0x4d, 0x59, 0x6e, 0x61, 0x99, 0x9a, 0xca, 0x90, 0x7e, 0x42, 0x44,
+	0xc8, 0x5c, 0xc6, 0x6c, 0xc8, 0xf8, 0xf8, 0x25, 0xe3, 0x81, 0x70, 0x19, 0x8b, 0x09, 0xba, 0x0b,
+	0x0a, 0x6f, 0x43, 0x68, 0xb6, 0xe3, 0xca, 0xe8, 0xf6, 0x5a, 0x78, 0xaf, 0xa2, 0xdb, 0xb0, 0x79,
+	0xc8, 0x78, 0x0e, 0x1c, 0x17, 0x17, 0x1c, 0x39, 0x0a, 0x65, 0x5d, 0x25, 0x02, 0xfe, 0x2e, 0x83,
+	0xc2, 0x56, 0xef, 0x3a, 0x7a, 0x87, 0xf0, 0x50, 0xa5, 0xe0, 0x80, 0xa0, 0x3e, 0x06, 0x34, 0x19,
+	0x70, 0x51, 0x13, 0x72, 0xe4, 0x84, 0x58, 0x94, 0x1d, 0x1b, 0x33, 0xf7, 0xc5, 0x29, 0xc8, 0x8a,
+	0x58, 0xb4, 0x56, 0x61, 0x46, 0xfe, 0xe7, 0x37, 0x1b, 0x65, 0xc1, 0xfd, 0xb6, 0x3d, 0x30, 0x29,
+	0x19, 0x38, 0xf4, 0x0c, 0x4b, 0x79, 0xf5, 0x57, 0x29, 0x06, 0x73, 0x22, 0xc1, 0x78, 0xaa, 0x6d,
+	0xbd, 0x2b, 0x9f, 0x0a, 0x41, 0xdc, 0xc5, 0xec, 0xbd, 0x0e, 0xd0, 0xd5, 0x5d, 0xed, 0xa9, 0x6e,
+	0x51, 0x62, 0x48, 0xa3, 0x87, 0x28, 0xa8, 0x0a, 0x05, 0x36, 0x1b, 0xb9, 0xc4, 0x90, 0x68, 0xdb,
+	0x9f, 0x87, 0xf6, 0x99, 0xff, 0x76, 0xfb, 0x8c, 0x5a, 0xb9, 0x30, 0x6e, 0xe5, 0xdf, 0xa4, 0x02,
+	0x37, 0x09, 0x10, 0xe1, 0xff, 0x9f, 0x1d, 0x7e, 0xcb, 0xeb, 0xc4, 0x68, 0x56, 0x44, 0x47, 0xb0,
+	0xea, 0x7b, 0xa9, 0x36, 0xe2, 0xde, 0xeb, 0xdd, 0xbb, 0x45, 0xdd, 0xbc, 0x7c, 0x12, 0x25, 0xbb,
+	0xe8, 0x63, 0x78, 0x75, 0x2c, 0x04, 0xf9, 0xaa, 0x53, 0x8b, 0x46, 0xa2, 0x57, 0xa2, 0x91, 0xc8,
+	0x53, 0x1d, 0x18, 0x2b, 0xfd, 0x2d, 0x9d, 0x63, 0x97, 0x95, 0x1e, 0xe1, 0x24, 0x3f, 0xf5, 0xf8,
+	0xaf, 0x41, 0x71, 0x48, 0x28, 0x2b, 0x87, 0x23, 0xc5, 0xdd, 0xb2, 0x20, 0xca, 0x92, 0xf1, 0x10,
+	0x5e, 0x99, 0x9a, 0xec, 0xd1, 0xf7, 0x40, 0x09, 0x70, 0x42, 0x32, 0xa6, 0x4e, 0xf2, 0xb1, 0x7f,
+	0xc0, 0xab, 0xfe, 0x29, 0x19, 0xa8, 0x8c, 0x56, 0x13, 0x0d, 0xc8, 0x0d, 0x89, 0x3b, 0xea, 0x0b,
+	0x7c, 0x5f, 0xda, 0x7e, 0x67, 0x31, 0x98, 0xc0, 0xa8, 0xa3, 0x3e, 0xc5, 0x52, 0x58, 0x7d, 0x0c,
+	0x39, 0x41, 0x41, 0x4b, 0x90, 0x7f, 0xb8, 0xff, 0x60, 0xff, 0xe0, 0xa3, 0xfd, 0x72, 0x02, 0x01,
+	0xe4, 0x76, 0xea, 0xf5, 0xc6, 0x61, 0xab, 0x9c, 0x44, 0x0a, 0x64, 0x77, 0x6a, 0x07, 0xb8, 0x55,
+	0x4e, 0x31, 0x32, 0x6e, 0x7c, 0xd8, 0xa8, 0xb7, 0xca, 0x69, 0xb4, 0x0a, 0x45, 0x31, 0xd6, 0xee,
+	0x1f, 0xe0, 0x9f, 0xec, 0xb4, 0xca, 0x99, 0x10, 0xe9, 0xa8, 0xb1, 0x7f, 0xaf, 0x81, 0xcb, 0x59,
+	0xf5, 0x5d, 0x56, 0x40, 0xc4, 0x00, 0x8b, 0xa0, 0x54, 0x48, 0x86, 0x4a, 0x05, 0xf5, 0x77, 0x29,
+	0xa8, 0xc6, 0xa3, 0x05, 0xf4, 0xe1, 0xd8, 0xc6, 0xb7, 0xcf, 0x01, 0x35, 0xc6, 0x76, 0x8f, 0xae,
+	0x43, 0x69, 0x48, 0x8e, 0x09, 0xed, 0xf4, 0x04, 0x7a, 0x11, 0x99, 0xad, 0x88, 0x8b, 0x92, 0xca,
+	0x85, 0x5c, 0xc1, 0xf6, 0x19, 0xe9, 0x50, 0x4d, 0x54, 0x2d, 0xe2, 0xd2, 0x29, 0x8c, 0x8d, 0x51,
+	0x8f, 0x04, 0x51, 0xfd, 0xf4, 0x5c, 0xb6, 0x54, 0x20, 0x8b, 0x1b, 0x2d, 0xfc, 0x71, 0x39, 0x8d,
+	0x10, 0x94, 0xf8, 0x50, 0x3b, 0xda, 0xdf, 0x39, 0x3c, 0x6a, 0x1e, 0x30, 0x5b, 0x5e, 0x80, 0x15,
+	0xcf, 0x96, 0x1e, 0x31, 0xab, 0x7e, 0x02, 0xa5, 0x68, 0x89, 0xce, 0x4c, 0x38, 0xb4, 0x47, 0x96,
+	0xc1, 0x8d, 0x91, 0xc5, 0x62, 0x82, 0x6e, 0x43, 0xf6, 0xc4, 0x16, 0x6e, 0x36, 0xfd, 0xae, 0x3d,
+	0xb2, 0x29, 0x09, 0x95, 0xf8, 0x82, 0x5b, 0xfd, 0x02, 0xb2, 0xdc, 0x6b, 0x98, 0x07, 0xf0, 0x62,
+	0x5b, 0x62, 0x1f, 0x36, 0x46, 0x9f, 0x00, 0xe8, 0x94, 0x0e, 0xcd, 0xf6, 0x28, 0x50, 0xbc, 0x31,
+	0xdd, 0xeb, 0x76, 0x3c, 0xbe, 0xda, 0x65, 0xe9, 0x7e, 0x6b, 0x81, 0x68, 0xc8, 0x05, 0x43, 0x0a,
+	0xd5, 0x7d, 0x28, 0x45, 0x65, 0xbd, 0x6c, 0x2d, 0xd6, 0x10, 0xcd, 0xd6, 0x02, 0x7c, 0xc9, 0x6c,
+	0xed, 0xe7, 0xfa, 0xb4, 0x68, 0xac, 0xf0, 0x89, 0xfa, 0x2c, 0x09, 0x85, 0xd6, 0xa9, 0x3c, 0x8f,
+	0x98, 0x9a, 0x3e, 0x10, 0x4d, 0x85, 0x2b, 0x58, 0xd1, 0x24, 0x48, 0xfb, 0xad, 0x87, 0x0f, 0xfc,
+	0x1b, 0x97, 0x59, 0xb4, 0x50, 0xf1, 0x7a, 0x30, 0xd2, 0xcb, 0xde, 0x07, 0xc5, 0x8f, 0x99, 0x0c,
+	0x44, 0xea, 0x86, 0x31, 0x24, 0xae, 0x2b, 0xef, 0xbd, 0x37, 0xe5, 0x2d, 0x22, 0xfb, 0xa9, 0xac,
+	0x91, 0xd3, 0x58, 0x4c, 0x54, 0x03, 0x56, 0xc6, 0x02, 0x2e, 0x7a, 0x1f, 0xf2, 0xce, 0xa8, 0xad,
+	0x79, 0xe6, 0x19, 0x7b, 0x12, 0xf0, 0xe0, 0xc9, 0xa8, 0xdd, 0x37, 0x3b, 0x0f, 0xc8, 0x99, 0xb7,
+	0x18, 0x67, 0xd4, 0x7e, 0x20, 0xac, 0x28, 0x7e, 0x25, 0x15, 0xfe, 0x95, 0x13, 0x28, 0x78, 0x97,
+	0x02, 0xfd, 0x10, 0x14, 0x3f, 0x96, 0xfb, 0x9d, 0xc3, 0xd8, 0x24, 0x20, 0xd5, 0x07, 0x22, 0x0c,
+	0xeb, 0xba, 0x66, 0xd7, 0x22, 0x86, 0x16, 0xc0, 0x58, 0xfe, 0x6b, 0x05, 0xbc, 0x22, 0x3e, 0xec,
+	0x79, 0x18, 0x56, 0xfd, 0x77, 0x12, 0x0a, 0x5e, 0x87, 0x08, 0xbd, 0x1b, 0xba, 0x77, 0xa5, 0x29,
+	0xf5, 0xb4, 0xc7, 0x18, 0x74, 0x79, 0xa2, 0x6b, 0x4d, 0x9d, 0x7f, 0xad, 0x71, 0xed, 0x3a, 0xaf,
+	0x71, 0x9a, 0x39, 0x77, 0xe3, 0xf4, 0x6d, 0x40, 0xd4, 0xa6, 0x7a, 0x5f, 0x3b, 0xb1, 0xa9, 0x69,
+	0x75, 0x35, 0x61, 0x6c, 0x81, 0x05, 0xca, 0xfc, 0xcb, 0x23, 0xfe, 0xe1, 0x90, 0xdb, 0xfd, 0x97,
+	0x49, 0x28, 0xf8, 0x41, 0xfd, 0xbc, 0x4d, 0x9b, 0x8b, 0x90, 0x93, 0x71, 0x4b, 0x74, 0x6d, 0xe4,
+	0xcc, 0xef, 0x1f, 0x66, 0x42, 0xfd, 0xc3, 0x2a, 0x14, 0x06, 0x84, 0xea, 0x3c, 0xb3, 0x89, 0x4a,
+	0xc2, 0x9f, 0xdf, 0x7c, 0x0f, 0x96, 0x42, 0xfd, 0x33, 0xe6, 0x79, 0xfb, 0x8d, 0x8f, 0xca, 0x89,
+	0x6a, 0xfe, 0xd9, 0x97, 0x57, 0xd3, 0xfb, 0xe4, 0x29, 0xbb, 0xb3, 0xb8, 0x51, 0x6f, 0x36, 0xea,
+	0x0f, 0xca, 0xc9, 0xea, 0xd2, 0xb3, 0x2f, 0xaf, 0xe6, 0x31, 0xe1, 0xb5, 0xfc, 0xcd, 0x26, 0x2c,
+	0x87, 0x4f, 0x25, 0x1a, 0xfa, 0x10, 0x94, 0xee, 0x3d, 0x3c, 0xdc, 0xdb, 0xad, 0xef, 0xb4, 0x1a,
+	0xda, 0xa3, 0x83, 0x56, 0xa3, 0x9c, 0x44, 0xaf, 0xc2, 0x85, 0xbd, 0xdd, 0x1f, 0x37, 0x5b, 0x5a,
+	0x7d, 0x6f, 0xb7, 0xb1, 0xdf, 0xd2, 0x76, 0x5a, 0xad, 0x9d, 0xfa, 0x83, 0x72, 0x6a, 0xfb, 0x0f,
+	0x0a, 0xac, 0xec, 0xd4, 0xea, 0xbb, 0x2c, 0x6c, 0x9b, 0x1d, 0x9d, 0x97, 0x79, 0x75, 0xc8, 0xf0,
+	0x42, 0x6e, 0xe6, 0xeb, 0x5a, 0x75, 0x76, 0x97, 0x07, 0xdd, 0x87, 0x2c, 0xaf, 0xf1, 0xd0, 0xec,
+	0xe7, 0xb6, 0xea, 0x9c, 0xb6, 0x0f, 0x5b, 0x0c, 0x77, 0x8f, 0x99, 0xef, 0x6f, 0xd5, 0xd9, 0x5d,
+	0x20, 0x84, 0x41, 0x09, 0xc0, 0xe7, 0xfc, 0xf7, 0xa8, 0xea, 0x02, 0xc1, 0x06, 0xed, 0x41, 0xde,
+	0x83, 0xf5, 0xf3, 0x5e, 0xc8, 0xaa, 0x73, 0xdb, 0x34, 0xcc, 0x5c, 0xa2, 0xfc, 0x9a, 0xfd, 0xdc,
+	0x57, 0x9d, 0xd3, 0x73, 0x42, 0xbb, 0x90, 0x93, 0x80, 0x6a, 0xce, 0xab, 0x57, 0x75, 0x5e, 0xdb,
+	0x85, 0x19, 0x2d, 0x28, 0x6c, 0xe7, 0x3f, 0x62, 0x56, 0x17, 0x68, 0xa7, 0xa1, 0x87, 0x00, 0xa1,
+	0x62, 0x6b, 0x81, 0xd7, 0xc9, 0xea, 0x22, 0x6d, 0x32, 0x74, 0x00, 0x05, 0x1f, 0x54, 0xcf, 0x7d,
+	0x2b, 0xac, 0xce, 0xef, 0x57, 0xa1, 0xc7, 0x50, 0x8c, 0x82, 0xc9, 0xc5, 0x5e, 0x00, 0xab, 0x0b,
+	0x36, 0xa2, 0x98, 0xfe, 0x28, 0xb2, 0x5c, 0xec, 0x45, 0xb0, 0xba, 0x60, 0x5f, 0x0a, 0x7d, 0x06,
+	0xab, 0x93, 0xc8, 0x6f, 0xf1, 0x07, 0xc2, 0xea, 0x39, 0x3a, 0x55, 0x68, 0x00, 0x68, 0x0a, 0x62,
+	0x3c, 0xc7, 0x7b, 0x61, 0xf5, 0x3c, 0x8d, 0xab, 0x5a, 0xe3, 0xab, 0x17, 0xeb, 0xc9, 0xaf, 0x5f,
+	0xac, 0x27, 0xff, 0xf1, 0x62, 0x3d, 0xf9, 0xfc, 0xe5, 0x7a, 0xe2, 0xeb, 0x97, 0xeb, 0x89, 0xbf,
+	0xbd, 0x5c, 0x4f, 0xfc, 0xec, 0xad, 0xae, 0x49, 0x7b, 0xa3, 0xf6, 0x66, 0xc7, 0x1e, 0x6c, 0x85,
+	0xff, 0x88, 0x30, 0xed, 0xcf, 0x11, 0xed, 0x1c, 0x4f, 0x2a, 0xb7, 0xfe, 0x13, 0x00, 0x00, 0xff,
+	0xff, 0x34, 0x1a, 0x9a, 0xa7, 0x3c, 0x21, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -5241,25 +5212,6 @@ func (m *ResponseCheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if len(m.MempoolError) > 0 {
-		i -= len(m.MempoolError)
-		copy(dAtA[i:], m.MempoolError)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.MempoolError)))
-		i--
-		dAtA[i] = 0x5a
-	}
-	if m.Priority != 0 {
-		i = encodeVarintTypes(dAtA, i, uint64(m.Priority))
-		i--
-		dAtA[i] = 0x50
-	}
-	if len(m.Sender) > 0 {
-		i -= len(m.Sender)
-		copy(dAtA[i:], m.Sender)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sender)))
-		i--
-		dAtA[i] = 0x4a
-	}
 	if len(m.Codespace) > 0 {
 		i -= len(m.Codespace)
 		copy(dAtA[i:], m.Codespace)
@@ -6854,17 +6806,6 @@ func (m *ResponseCheckTx) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	l = len(m.Sender)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.Priority != 0 {
-		n += 1 + sovTypes(uint64(m.Priority))
-	}
-	l = len(m.MempoolError)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
 	return n
 }
 
@@ -11079,89 +11020,6 @@ func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error {
 			}
 			m.Codespace = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
-		case 9:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Sender = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 10:
-			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
-			}
-			m.Priority = 0
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				m.Priority |= int64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-		case 11:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field MempoolError", wireType)
-			}
-			var stringLen uint64
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				stringLen |= uint64(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			intStringLen := int(stringLen)
-			if intStringLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + intStringLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.MempoolError = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTypes(dAtA[iNdEx:])

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

@@ -1,7 +1,7 @@
-package blocksync
+package blockchain
 
 import (
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
 	"github.com/tendermint/tendermint/types"
 )
 

blockchain/v0/pool.go

@@ -1,17 +1,17 @@
-package blocksync
+package v0
 
 import (
-	"context"
 	"errors"
 	"fmt"
 	"math"
-	"sync"
 	"sync/atomic"
 	"time"
 
-	"github.com/tendermint/tendermint/internal/libs/flowrate"
+	flow "github.com/tendermint/tendermint/libs/flowrate"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
+	tmsync "github.com/tendermint/tendermint/libs/sync"
+	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -63,22 +63,20 @@ var peerTimeout = 15 * time.Second // not const so we can override with tests
 // PeerID responsible for delivering the block.
 type BlockRequest struct {
 	Height int64
-	PeerID types.NodeID
+	PeerID p2p.NodeID
 }
 
-// BlockPool keeps track of the block sync peers, block requests and block responses.
+// BlockPool keeps track of the fast sync peers, block requests and block responses.
 type BlockPool struct {
 	service.BaseService
-	logger log.Logger
-
 	lastAdvance time.Time
 
-	mtx sync.RWMutex
+	mtx tmsync.RWMutex
 	// block requests
 	requesters map[int64]*bpRequester
 	height     int64 // the lowest key in requesters.
 	// peers
-	peers         map[types.NodeID]*bpPeer
+	peers         map[p2p.NodeID]*bpPeer
 	maxPeerHeight int64 // the biggest reported height
 
 	// atomic
@@ -86,57 +84,35 @@ type BlockPool struct {
 
 	requestsCh chan<- BlockRequest
 	errorsCh   chan<- peerError
-	exitedCh   chan struct{}
-
-	startHeight               int64
-	lastHundredBlockTimeStamp time.Time
-	lastSyncRate              float64
 }
 
 // NewBlockPool returns a new BlockPool with the height equal to start. Block
 // requests and errors will be sent to requestsCh and errorsCh accordingly.
-func NewBlockPool(
-	logger log.Logger,
-	start int64,
-	requestsCh chan<- BlockRequest,
-	errorsCh chan<- peerError,
-) *BlockPool {
-
+func NewBlockPool(start int64, requestsCh chan<- BlockRequest, errorsCh chan<- peerError) *BlockPool {
 	bp := &BlockPool{
-		logger:       logger,
-		peers:        make(map[types.NodeID]*bpPeer),
-		requesters:   make(map[int64]*bpRequester),
-		height:       start,
-		startHeight:  start,
-		numPending:   0,
-		exitedCh:     make(chan struct{}),
-		requestsCh:   requestsCh,
-		errorsCh:     errorsCh,
-		lastSyncRate: 0,
+		peers: make(map[p2p.NodeID]*bpPeer),
+
+		requesters: make(map[int64]*bpRequester),
+		height:     start,
+		numPending: 0,
+
+		requestsCh: requestsCh,
+		errorsCh:   errorsCh,
 	}
-	bp.BaseService = *service.NewBaseService(logger, "BlockPool", bp)
+	bp.BaseService = *service.NewBaseService(nil, "BlockPool", bp)
 	return bp
 }
 
 // OnStart implements service.Service by spawning requesters routine and recording
 // pool's start time.
-func (pool *BlockPool) OnStart(ctx context.Context) error {
+func (pool *BlockPool) OnStart() error {
 	pool.lastAdvance = time.Now()
-	pool.lastHundredBlockTimeStamp = pool.lastAdvance
-	go pool.makeRequestersRoutine(ctx)
-
-	go func() {
-		defer close(pool.exitedCh)
-		pool.Wait()
-	}()
-
+	go pool.makeRequestersRoutine()
 	return nil
 }
 
-func (*BlockPool) OnStop() {}
-
 // spawns requesters as needed
-func (pool *BlockPool) makeRequestersRoutine(ctx context.Context) {
+func (pool *BlockPool) makeRequestersRoutine() {
 	for {
 		if !pool.IsRunning() {
 			break
@@ -156,7 +132,7 @@ func (pool *BlockPool) makeRequestersRoutine(ctx context.Context) {
 			pool.removeTimedoutPeers()
 		default:
 			// request for more blocks.
-			pool.makeNextRequester(ctx)
+			pool.makeNextRequester()
 		}
 	}
 }
@@ -173,7 +149,7 @@ func (pool *BlockPool) removeTimedoutPeers() {
 			if curRate != 0 && curRate < minRecvRate {
 				err := errors.New("peer is not sending us data fast enough")
 				pool.sendError(err, peer.id)
-				pool.logger.Error("SendTimeout", "peer", peer.id,
+				pool.Logger.Error("SendTimeout", "peer", peer.id,
 					"reason", err,
 					"curRate", fmt.Sprintf("%d KB/s", curRate/1024),
 					"minRate", fmt.Sprintf("%d KB/s", minRecvRate/1024))
@@ -236,24 +212,11 @@ func (pool *BlockPool) PopRequest() {
 
 	if r := pool.requesters[pool.height]; r != nil {
 		if err := r.Stop(); err != nil {
-			pool.logger.Error("Error stopping requester", "err", err)
+			pool.Logger.Error("Error stopping requester", "err", err)
 		}
 		delete(pool.requesters, pool.height)
 		pool.height++
 		pool.lastAdvance = time.Now()
-
-		// the lastSyncRate will be updated every 100 blocks, it uses the adaptive filter
-		// to smooth the block sync rate and the unit represents the number of blocks per second.
-		if (pool.height-pool.startHeight)%100 == 0 {
-			newSyncRate := 100 / time.Since(pool.lastHundredBlockTimeStamp).Seconds()
-			if pool.lastSyncRate == 0 {
-				pool.lastSyncRate = newSyncRate
-			} else {
-				pool.lastSyncRate = 0.9*pool.lastSyncRate + 0.1*newSyncRate
-			}
-			pool.lastHundredBlockTimeStamp = time.Now()
-		}
-
 	} else {
 		panic(fmt.Sprintf("Expected requester to pop, got nothing at height %v", pool.height))
 	}
@@ -262,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) types.NodeID {
+func (pool *BlockPool) RedoRequest(height int64) p2p.NodeID {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
 	request := pool.requesters[height]
 	peerID := request.getPeerID()
-	if peerID != types.NodeID("") {
+	if peerID != p2p.NodeID("") {
 		// RemovePeer will redo all requesters associated with this peer.
 		pool.removePeer(peerID)
 	}
@@ -277,13 +240,13 @@ func (pool *BlockPool) RedoRequest(height int64) types.NodeID {
 
 // 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 types.NodeID, 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.Error("peer sent us a block we didn't expect",
+		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 {
@@ -303,7 +266,7 @@ func (pool *BlockPool) AddBlock(peerID types.NodeID, block *types.Block, blockSi
 		}
 	} else {
 		err := errors.New("requester is different or block already exists")
-		pool.logger.Error(err.Error(), "peer", peerID, "requester", requester.getPeerID(), "blockHeight", block.Height)
+		pool.Logger.Error(err.Error(), "peer", peerID, "requester", requester.getPeerID(), "blockHeight", block.Height)
 		pool.sendError(err, peerID)
 	}
 }
@@ -324,7 +287,7 @@ func (pool *BlockPool) LastAdvance() time.Time {
 }
 
 // SetPeerRange sets the peer's alleged blockchain base and height.
-func (pool *BlockPool) SetPeerRange(peerID types.NodeID, base int64, height int64) {
+func (pool *BlockPool) SetPeerRange(peerID p2p.NodeID, base int64, height int64) {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
@@ -334,7 +297,7 @@ func (pool *BlockPool) SetPeerRange(peerID types.NodeID, base int64, height int6
 		peer.height = height
 	} else {
 		peer = newBPPeer(pool, peerID, base, height)
-		peer.logger = pool.logger.With("peer", peerID)
+		peer.setLogger(pool.Logger.With("peer", peerID))
 		pool.peers[peerID] = peer
 	}
 
@@ -345,14 +308,14 @@ func (pool *BlockPool) SetPeerRange(peerID types.NodeID, base int64, height int6
 
 // 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 types.NodeID) {
+func (pool *BlockPool) RemovePeer(peerID p2p.NodeID) {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
 	pool.removePeer(peerID)
 }
 
-func (pool *BlockPool) removePeer(peerID types.NodeID) {
+func (pool *BlockPool) removePeer(peerID p2p.NodeID) {
 	for _, requester := range pool.requesters {
 		if requester.getPeerID() == peerID {
 			requester.redo(peerID)
@@ -409,7 +372,7 @@ func (pool *BlockPool) pickIncrAvailablePeer(height int64) *bpPeer {
 	return nil
 }
 
-func (pool *BlockPool) makeNextRequester(ctx context.Context) {
+func (pool *BlockPool) makeNextRequester() {
 	pool.mtx.Lock()
 	defer pool.mtx.Unlock()
 
@@ -423,9 +386,9 @@ func (pool *BlockPool) makeNextRequester(ctx context.Context) {
 	pool.requesters[nextHeight] = request
 	atomic.AddInt32(&pool.numPending, 1)
 
-	err := request.Start(ctx)
+	err := request.Start()
 	if err != nil {
-		request.logger.Error("Error starting request", "err", err)
+		request.Logger.Error("Error starting request", "err", err)
 	}
 }
 
@@ -433,14 +396,14 @@ func (pool *BlockPool) requestersLen() int64 {
 	return int64(len(pool.requesters))
 }
 
-func (pool *BlockPool) sendRequest(height int64, peerID types.NodeID) {
+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 types.NodeID) {
+func (pool *BlockPool) sendError(err error, peerID p2p.NodeID) {
 	if !pool.IsRunning() {
 		return
 	}
@@ -466,20 +429,6 @@ func (pool *BlockPool) debug() string {
 	return str
 }
 
-func (pool *BlockPool) targetSyncBlocks() int64 {
-	pool.mtx.RLock()
-	defer pool.mtx.RUnlock()
-
-	return pool.maxPeerHeight - pool.startHeight + 1
-}
-
-func (pool *BlockPool) getLastSyncRate() float64 {
-	pool.mtx.RLock()
-	defer pool.mtx.RUnlock()
-
-	return pool.lastSyncRate
-}
-
 //-------------------------------------
 
 type bpPeer struct {
@@ -488,15 +437,15 @@ type bpPeer struct {
 	height      int64
 	base        int64
 	pool        *BlockPool
-	id          types.NodeID
-	recvMonitor *flowrate.Monitor
+	id          p2p.NodeID
+	recvMonitor *flow.Monitor
 
 	timeout *time.Timer
 
 	logger log.Logger
 }
 
-func newBPPeer(pool *BlockPool, peerID types.NodeID, base int64, height int64) *bpPeer {
+func newBPPeer(pool *BlockPool, peerID p2p.NodeID, base int64, height int64) *bpPeer {
 	peer := &bpPeer{
 		pool:       pool,
 		id:         peerID,
@@ -508,8 +457,12 @@ func newBPPeer(pool *BlockPool, peerID types.NodeID, base int64, height int64) *
 	return peer
 }
 
+func (peer *bpPeer) setLogger(l log.Logger) {
+	peer.logger = l
+}
+
 func (peer *bpPeer) resetMonitor() {
-	peer.recvMonitor = flowrate.New(time.Second, time.Second*40)
+	peer.recvMonitor = flow.New(time.Second, time.Second*40)
 	initialValue := float64(minRecvRate) * math.E
 	peer.recvMonitor.SetREMA(initialValue)
 }
@@ -554,24 +507,22 @@ func (peer *bpPeer) onTimeout() {
 
 type bpRequester struct {
 	service.BaseService
-	logger     log.Logger
 	pool       *BlockPool
 	height     int64
 	gotBlockCh chan struct{}
-	redoCh     chan types.NodeID // redo may send multitime, add peerId to identify repeat
+	redoCh     chan p2p.NodeID // redo may send multitime, add peerId to identify repeat
 
-	mtx    sync.Mutex
-	peerID types.NodeID
+	mtx    tmsync.Mutex
+	peerID p2p.NodeID
 	block  *types.Block
 }
 
 func newBPRequester(pool *BlockPool, height int64) *bpRequester {
 	bpr := &bpRequester{
-		logger:     pool.logger,
 		pool:       pool,
 		height:     height,
 		gotBlockCh: make(chan struct{}, 1),
-		redoCh:     make(chan types.NodeID, 1),
+		redoCh:     make(chan p2p.NodeID, 1),
 
 		peerID: "",
 		block:  nil,
@@ -580,15 +531,13 @@ func newBPRequester(pool *BlockPool, height int64) *bpRequester {
 	return bpr
 }
 
-func (bpr *bpRequester) OnStart(ctx context.Context) error {
-	go bpr.requestRoutine(ctx)
+func (bpr *bpRequester) OnStart() error {
+	go bpr.requestRoutine()
 	return nil
 }
 
-func (*bpRequester) OnStop() {}
-
 // Returns true if the peer matches and block doesn't already exist.
-func (bpr *bpRequester) setBlock(block *types.Block, peerID types.NodeID) 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()
@@ -610,7 +559,7 @@ func (bpr *bpRequester) getBlock() *types.Block {
 	return bpr.block
 }
 
-func (bpr *bpRequester) getPeerID() types.NodeID {
+func (bpr *bpRequester) getPeerID() p2p.NodeID {
 	bpr.mtx.Lock()
 	defer bpr.mtx.Unlock()
 	return bpr.peerID
@@ -632,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 types.NodeID) {
+func (bpr *bpRequester) redo(peerID p2p.NodeID) {
 	select {
 	case bpr.redoCh <- peerID:
 	default:
@@ -641,13 +590,7 @@ func (bpr *bpRequester) redo(peerID types.NodeID) {
 
 // Responsible for making more requests as necessary
 // Returns only when a block is found (e.g. AddBlock() is called)
-func (bpr *bpRequester) requestRoutine(ctx context.Context) {
-	bprPoolDone := make(chan struct{})
-	go func() {
-		defer close(bprPoolDone)
-		bpr.pool.Wait()
-	}()
-
+func (bpr *bpRequester) requestRoutine() {
 OUTER_LOOP:
 	for {
 		// Pick a peer to send request to.
@@ -673,13 +616,13 @@ OUTER_LOOP:
 	WAIT_LOOP:
 		for {
 			select {
-			case <-ctx.Done():
-				return
-			case <-bpr.pool.exitedCh:
+			case <-bpr.pool.Quit():
 				if err := bpr.Stop(); err != nil {
-					bpr.logger.Error("Error stopped requester", "err", err)
+					bpr.Logger.Error("Error stopped requester", "err", err)
 				}
 				return
+			case <-bpr.Quit():
+				return
 			case peerID := <-bpr.redoCh:
 				if peerID == bpr.peerID {
 					bpr.reset()

blockchain/v0/pool_test.go

@@ -1,7 +1,6 @@
-package blocksync
+package v0
 
 import (
-	"context"
 	"fmt"
 	mrand "math/rand"
 	"testing"
@@ -12,6 +11,7 @@ import (
 
 	"github.com/tendermint/tendermint/libs/log"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
+	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -20,7 +20,7 @@ func init() {
 }
 
 type testPeer struct {
-	id        types.NodeID
+	id        p2p.NodeID
 	base      int64
 	height    int64
 	inputChan chan inputData // make sure each peer's data is sequential
@@ -50,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[types.NodeID]testPeer
+type testPeers map[p2p.NodeID]testPeer
 
 func (ps testPeers) start() {
 	for _, v := range ps {
@@ -67,7 +67,7 @@ func (ps testPeers) stop() {
 func makePeers(numPeers int, minHeight, maxHeight int64) testPeers {
 	peers := make(testPeers, numPeers)
 	for i := 0; i < numPeers; i++ {
-		peerID := types.NodeID(tmrand.Str(12))
+		peerID := p2p.NodeID(tmrand.Str(12))
 		height := minHeight + mrand.Int63n(maxHeight-minHeight)
 		base := minHeight + int64(i)
 		if base > height {
@@ -79,20 +79,23 @@ func makePeers(numPeers int, minHeight, maxHeight int64) testPeers {
 }
 
 func TestBlockPoolBasic(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	start := int64(42)
 	peers := makePeers(10, start+1, 1000)
 	errorsCh := make(chan peerError, 1000)
 	requestsCh := make(chan BlockRequest, 1000)
-	pool := NewBlockPool(log.TestingLogger(), start, requestsCh, errorsCh)
+	pool := NewBlockPool(start, requestsCh, errorsCh)
+	pool.SetLogger(log.TestingLogger())
 
-	if err := pool.Start(ctx); err != nil {
+	err := pool.Start()
+	if err != nil {
 		t.Error(err)
 	}
 
-	t.Cleanup(func() { cancel(); pool.Wait() })
+	t.Cleanup(func() {
+		if err := pool.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
 	peers.start()
 	defer peers.stop()
@@ -136,19 +139,21 @@ func TestBlockPoolBasic(t *testing.T) {
 }
 
 func TestBlockPoolTimeout(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	start := int64(42)
 	peers := makePeers(10, start+1, 1000)
 	errorsCh := make(chan peerError, 1000)
 	requestsCh := make(chan BlockRequest, 1000)
-	pool := NewBlockPool(log.TestingLogger(), start, requestsCh, errorsCh)
-	err := pool.Start(ctx)
+	pool := NewBlockPool(start, requestsCh, errorsCh)
+	pool.SetLogger(log.TestingLogger())
+	err := pool.Start()
 	if err != nil {
 		t.Error(err)
 	}
-	t.Cleanup(func() { cancel(); pool.Wait() })
+	t.Cleanup(func() {
+		if err := pool.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
 	for _, peer := range peers {
 		t.Logf("Peer %v", peer.id)
@@ -178,7 +183,7 @@ func TestBlockPoolTimeout(t *testing.T) {
 
 	// Pull from channels
 	counter := 0
-	timedOut := map[types.NodeID]struct{}{}
+	timedOut := map[p2p.NodeID]struct{}{}
 	for {
 		select {
 		case err := <-errorsCh:
@@ -197,22 +202,24 @@ func TestBlockPoolTimeout(t *testing.T) {
 }
 
 func TestBlockPoolRemovePeer(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	peers := make(testPeers, 10)
 	for i := 0; i < 10; i++ {
-		peerID := types.NodeID(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)}
 	}
 	requestsCh := make(chan BlockRequest)
 	errorsCh := make(chan peerError)
 
-	pool := NewBlockPool(log.TestingLogger(), 1, requestsCh, errorsCh)
-	err := pool.Start(ctx)
+	pool := NewBlockPool(1, requestsCh, errorsCh)
+	pool.SetLogger(log.TestingLogger())
+	err := pool.Start()
 	require.NoError(t, err)
-	t.Cleanup(func() { cancel(); pool.Wait() })
+	t.Cleanup(func() {
+		if err := pool.Stop(); err != nil {
+			t.Error(err)
+		}
+	})
 
 	// add peers
 	for peerID, peer := range peers {
@@ -221,10 +228,10 @@ func TestBlockPoolRemovePeer(t *testing.T) {
 	assert.EqualValues(t, 10, pool.MaxPeerHeight())
 
 	// remove not-existing peer
-	assert.NotPanics(t, func() { pool.RemovePeer(types.NodeID("Superman")) })
+	assert.NotPanics(t, func() { pool.RemovePeer(p2p.NodeID("Superman")) })
 
 	// remove peer with biggest height
-	pool.RemovePeer(types.NodeID("10"))
+	pool.RemovePeer(p2p.NodeID("10"))
 	assert.EqualValues(t, 9, pool.MaxPeerHeight())
 
 	// remove all peers

blockchain/v0/reactor.go

@@ -1,29 +1,49 @@
-package blocksync
+package v0
 
 import (
-	"context"
-	"errors"
 	"fmt"
-	"runtime/debug"
 	"sync"
 	"time"
 
-	"github.com/tendermint/tendermint/internal/consensus"
-	"github.com/tendermint/tendermint/internal/p2p"
-	sm "github.com/tendermint/tendermint/internal/state"
-	"github.com/tendermint/tendermint/internal/store"
+	bc "github.com/tendermint/tendermint/blockchain"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
-	tmsync "github.com/tendermint/tendermint/libs/sync"
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
+	"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)
+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 (
-	// BlockSyncChannel is a channel for blocks and status updates
-	BlockSyncChannel = p2p.ChannelID(0x40)
+	// BlockchainChannel is a channel for blocks and status updates
+	BlockchainChannel = p2p.ChannelID(0x40)
 
 	trySyncIntervalMS = 10
 
@@ -37,36 +57,24 @@ const (
 	syncTimeout = 60 * time.Second
 )
 
-func GetChannelDescriptor() *p2p.ChannelDescriptor {
-	return &p2p.ChannelDescriptor{
-		ID:                  BlockSyncChannel,
-		MessageType:         new(bcproto.Message),
-		Priority:            5,
-		SendQueueCapacity:   1000,
-		RecvBufferCapacity:  1024,
-		RecvMessageCapacity: MaxMsgSize,
-	}
-}
-
 type consensusReactor interface {
-	// For when we switch from block sync reactor to the consensus
+	// For when we switch from blockchain reactor and fast sync to the consensus
 	// machine.
-	SwitchToConsensus(ctx context.Context, state sm.State, skipWAL bool)
+	SwitchToConsensus(state sm.State, skipWAL bool)
 }
 
 type peerError struct {
 	err    error
-	peerID types.NodeID
+	peerID p2p.NodeID
 }
 
 func (e peerError) Error() string {
 	return fmt.Sprintf("error with peer %v: %s", e.peerID, e.err.Error())
 }
 
-// Reactor handles long-term catchup syncing.
+// BlockchainReactor handles long-term catchup syncing.
 type Reactor struct {
 	service.BaseService
-	logger log.Logger
 
 	// immutable
 	initialState sm.State
@@ -75,18 +83,11 @@ type Reactor struct {
 	store       *store.BlockStore
 	pool        *BlockPool
 	consReactor consensusReactor
-	blockSync   *tmsync.AtomicBool
+	fastSync    bool
 
-	blockSyncCh *p2p.Channel
-	// blockSyncOutBridgeCh defines a channel that acts as a bridge between sending Envelope
-	// messages that the reactor will consume in processBlockSyncCh and receiving messages
-	// from the peer updates channel and other goroutines. We do this instead of directly
-	// sending on blockSyncCh.Out to avoid race conditions in the case where other goroutines
-	// send Envelopes directly to the to blockSyncCh.Out channel, since processBlockSyncCh
-	// may close the blockSyncCh.Out channel at the same time that other goroutines send to
-	// blockSyncCh.Out.
-	blockSyncOutBridgeCh chan p2p.Envelope
-	peerUpdates          *p2p.PeerUpdates
+	blockchainCh *p2p.Channel
+	peerUpdates  *p2p.PeerUpdates
+	closeCh      chan struct{}
 
 	requestsCh <-chan BlockRequest
 	errorsCh   <-chan peerError
@@ -95,10 +96,6 @@ type Reactor struct {
 	// requestRoutine spawned goroutines when stopping the reactor and before
 	// stopping the p2p Channel(s).
 	poolWG sync.WaitGroup
-
-	metrics *consensus.Metrics
-
-	syncStartTime time.Time
 }
 
 // NewReactor returns new reactor instance.
@@ -108,10 +105,9 @@ func NewReactor(
 	blockExec *sm.BlockExecutor,
 	store *store.BlockStore,
 	consReactor consensusReactor,
-	blockSyncCh *p2p.Channel,
+	blockchainCh *p2p.Channel,
 	peerUpdates *p2p.PeerUpdates,
-	blockSync bool,
-	metrics *consensus.Metrics,
+	fastSync bool,
 ) (*Reactor, error) {
 	if state.LastBlockHeight != store.Height() {
 		return nil, fmt.Errorf("state (%v) and store (%v) height mismatch", state.LastBlockHeight, store.Height())
@@ -126,23 +122,20 @@ func NewReactor(
 	errorsCh := make(chan peerError, maxPeerErrBuffer) // NOTE: The capacity should be larger than the peer count.
 
 	r := &Reactor{
-		logger:               logger,
-		initialState:         state,
-		blockExec:            blockExec,
-		store:                store,
-		pool:                 NewBlockPool(logger, startHeight, requestsCh, errorsCh),
-		consReactor:          consReactor,
-		blockSync:            tmsync.NewBool(blockSync),
-		requestsCh:           requestsCh,
-		errorsCh:             errorsCh,
-		blockSyncCh:          blockSyncCh,
-		blockSyncOutBridgeCh: make(chan p2p.Envelope),
-		peerUpdates:          peerUpdates,
-		metrics:              metrics,
-		syncStartTime:        time.Time{},
+		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, "BlockSync", r)
+	r.BaseService = *service.NewBaseService(logger, "Blockchain", r)
 	return r, nil
 }
 
@@ -151,23 +144,20 @@ func NewReactor(
 // messages on that p2p channel accordingly. The caller must be sure to execute
 // OnStop to ensure the outbound p2p Channels are closed.
 //
-// If blockSync is enabled, we also start the pool and the pool processing
+// 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(ctx context.Context) error {
-	if r.blockSync.IsSet() {
-		if err := r.pool.Start(ctx); err != nil {
+func (r *Reactor) OnStart() error {
+	if r.fastSync {
+		if err := r.pool.Start(); err != nil {
 			return err
 		}
-		r.poolWG.Add(1)
-		go r.requestRoutine(ctx)
 
 		r.poolWG.Add(1)
-		go r.poolRoutine(ctx, false)
+		go r.poolRoutine(false)
 	}
 
-	go r.processBlockSyncCh(ctx)
-	go r.processBlockSyncBridge(ctx)
-	go r.processPeerUpdates(ctx)
+	go r.processBlockchainCh()
+	go r.processPeerUpdates()
 
 	return nil
 }
@@ -175,50 +165,62 @@ func (r *Reactor) OnStart(ctx context.Context) error {
 // OnStop stops the reactor by signaling to all spawned goroutines to exit and
 // blocking until they all exit.
 func (r *Reactor) OnStop() {
-	if r.blockSync.IsSet() {
+	if r.fastSync {
 		if err := r.pool.Stop(); err != nil {
-			r.logger.Error("failed to stop pool", "err", err)
+			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(ctx context.Context, msg *bcproto.BlockRequest, peerID types.NodeID) error {
+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 err
+			r.Logger.Error("failed to convert msg to protobuf", "err", err)
+			return
 		}
 
-		return r.blockSyncCh.Send(ctx, p2p.Envelope{
+		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)
-
-	return r.blockSyncCh.Send(ctx, p2p.Envelope{
+	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},
-	})
+	}
 }
 
-// handleBlockSyncMessage handles envelopes sent from peers on the
-// BlockSyncChannel. It returns an error only if the Envelope.Message is unknown
+// 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) handleBlockSyncMessage(ctx context.Context, envelope *p2p.Envelope) error {
-	logger := r.logger.With("peer", envelope.From)
+func (r *Reactor) handleBlockchainMessage(envelope p2p.Envelope) error {
+	logger := r.Logger.With("peer", envelope.From)
 
 	switch msg := envelope.Message.(type) {
 	case *bcproto.BlockRequest:
-		return r.respondToPeer(ctx, msg, envelope.From)
+		r.respondToPeer(msg, envelope.From)
+
 	case *bcproto.BlockResponse:
 		block, err := types.BlockFromProto(msg.Block)
 		if err != nil {
@@ -229,13 +231,14 @@ func (r *Reactor) handleBlockSyncMessage(ctx context.Context, envelope *p2p.Enve
 		r.pool.AddBlock(envelope.From, block, block.Size())
 
 	case *bcproto.StatusRequest:
-		return r.blockSyncCh.Send(ctx, p2p.Envelope{
+		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)
 
@@ -252,23 +255,19 @@ func (r *Reactor) handleBlockSyncMessage(ctx context.Context, envelope *p2p.Enve
 // 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(ctx context.Context, chID p2p.ChannelID, envelope *p2p.Envelope) (err error) {
+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,
-				"stack", string(debug.Stack()),
-			)
+			r.Logger.Error("recovering from processing message panic", "err", err)
 		}
 	}()
 
-	r.logger.Debug("received message", "message", envelope.Message, "peer", envelope.From)
+	r.Logger.Debug("received message", "message", envelope.Message, "peer", envelope.From)
 
 	switch chID {
-	case BlockSyncChannel:
-		err = r.handleBlockSyncMessage(ctx, envelope)
+	case BlockchainChannel:
+		err = r.handleBlockchainMessage(envelope)
 
 	default:
 		err = fmt.Errorf("unknown channel ID (%d) for envelope (%v)", chID, envelope)
@@ -277,47 +276,35 @@ func (r *Reactor) handleMessage(ctx context.Context, chID p2p.ChannelID, envelop
 	return err
 }
 
-// processBlockSyncCh initiates a blocking process where we listen for and handle
-// envelopes on the BlockSyncChannel and blockSyncOutBridgeCh. Any error encountered during
-// message execution will result in a PeerError being sent on the BlockSyncChannel.
-// When the reactor is stopped, we will catch the signal and close the p2p Channel
+// 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) processBlockSyncCh(ctx context.Context) {
-	iter := r.blockSyncCh.Receive(ctx)
-	for iter.Next(ctx) {
-		envelope := iter.Envelope()
-		if err := r.handleMessage(ctx, r.blockSyncCh.ID, envelope); err != nil {
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return
-			}
+func (r *Reactor) processBlockchainCh() {
+	defer r.blockchainCh.Close()
 
-			r.logger.Error("failed to process message", "ch_id", r.blockSyncCh.ID, "envelope", envelope, "err", err)
-			if serr := r.blockSyncCh.SendError(ctx, p2p.PeerError{
-				NodeID: envelope.From,
-				Err:    err,
-			}); serr != nil {
-				return
-			}
-		}
-	}
-}
-
-func (r *Reactor) processBlockSyncBridge(ctx context.Context) {
 	for {
 		select {
-		case <-ctx.Done():
-			return
-		case envelope := <-r.blockSyncOutBridgeCh:
-			if err := r.blockSyncCh.Send(ctx, envelope); err != nil {
-				return
+		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)
+	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 {
@@ -327,7 +314,7 @@ func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
 	switch peerUpdate.Status {
 	case p2p.PeerStatusUp:
 		// send a status update the newly added peer
-		r.blockSyncOutBridgeCh <- p2p.Envelope{
+		r.blockchainCh.Out <- p2p.Envelope{
 			To: peerUpdate.NodeID,
 			Message: &bcproto.StatusResponse{
 				Base:   r.store.Base(),
@@ -343,74 +330,74 @@ func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
 // 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(ctx context.Context) {
+func (r *Reactor) processPeerUpdates() {
+	defer r.peerUpdates.Close()
+
 	for {
 		select {
-		case <-ctx.Done():
-			r.logger.Debug("stopped listening on peer updates channel; closing...")
-			return
 		case peerUpdate := <-r.peerUpdates.Updates():
 			r.processPeerUpdate(peerUpdate)
+
+		case <-r.closeCh:
+			r.Logger.Debug("stopped listening on peer updates channel; closing...")
+			return
 		}
 	}
 }
 
-// SwitchToBlockSync is called by the state sync reactor when switching to fast
+// SwitchToFastSync is called by the state sync reactor when switching to fast
 // sync.
-func (r *Reactor) SwitchToBlockSync(ctx context.Context, state sm.State) error {
-	r.blockSync.Set()
+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(ctx); err != nil {
+	if err := r.pool.Start(); err != nil {
 		return err
 	}
 
-	r.syncStartTime = time.Now()
-
 	r.poolWG.Add(1)
-	go r.requestRoutine(ctx)
-
-	r.poolWG.Add(1)
-	go r.poolRoutine(ctx, true)
+	go r.poolRoutine(true)
 
 	return nil
 }
 
-func (r *Reactor) requestRoutine(ctx context.Context) {
+func (r *Reactor) requestRoutine() {
 	statusUpdateTicker := time.NewTicker(statusUpdateIntervalSeconds * time.Second)
 	defer statusUpdateTicker.Stop()
 
+	r.poolWG.Add(1)
 	defer r.poolWG.Done()
 
 	for {
 		select {
-		case <-ctx.Done():
+		case <-r.closeCh:
 			return
+
+		case <-r.pool.Quit():
+			return
+
 		case request := <-r.requestsCh:
-			r.blockSyncOutBridgeCh <- p2p.Envelope{
+			r.blockchainCh.Out <- p2p.Envelope{
 				To:      request.PeerID,
 				Message: &bcproto.BlockRequest{Height: request.Height},
 			}
+
 		case pErr := <-r.errorsCh:
-			if err := r.blockSyncCh.SendError(ctx, p2p.PeerError{
+			r.blockchainCh.Error <- p2p.PeerError{
 				NodeID: pErr.peerID,
 				Err:    pErr.err,
-			}); err != nil {
-				return
 			}
+
 		case <-statusUpdateTicker.C:
 			r.poolWG.Add(1)
 
 			go func() {
 				defer r.poolWG.Done()
 
-				select {
-				case r.blockSyncOutBridgeCh <- p2p.Envelope{
+				r.blockchainCh.Out <- p2p.Envelope{
 					Broadcast: true,
 					Message:   &bcproto.StatusRequest{},
-				}:
-				case <-ctx.Done():
 				}
 			}()
 		}
@@ -421,7 +408,7 @@ func (r *Reactor) requestRoutine(ctx context.Context) {
 // do.
 //
 // NOTE: Don't sleep in the FOR_LOOP or otherwise slow it down!
-func (r *Reactor) poolRoutine(ctx context.Context, stateSynced bool) {
+func (r *Reactor) poolRoutine(stateSynced bool) {
 	var (
 		trySyncTicker           = time.NewTicker(trySyncIntervalMS * time.Millisecond)
 		switchToConsensusTicker = time.NewTicker(switchToConsensusIntervalSeconds * time.Second)
@@ -440,6 +427,8 @@ func (r *Reactor) poolRoutine(ctx context.Context, stateSynced bool) {
 	defer trySyncTicker.Stop()
 	defer switchToConsensusTicker.Stop()
 
+	go r.requestRoutine()
+
 	defer r.poolWG.Done()
 
 FOR_LOOP:
@@ -451,7 +440,7 @@ FOR_LOOP:
 				lastAdvance                       = r.pool.LastAdvance()
 			)
 
-			r.logger.Debug(
+			r.Logger.Debug(
 				"consensus ticker",
 				"num_pending", numPending,
 				"total", lenRequesters,
@@ -460,13 +449,13 @@ FOR_LOOP:
 
 			switch {
 			case r.pool.IsCaughtUp():
-				r.logger.Info("switching to consensus reactor", "height", height)
+				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)
+				r.Logger.Error("no progress since last advance", "last_advance", lastAdvance)
 
 			default:
-				r.logger.Info(
+				r.Logger.Info(
 					"not caught up yet",
 					"height", height,
 					"max_peer_height", r.pool.MaxPeerHeight(),
@@ -476,13 +465,11 @@ FOR_LOOP:
 			}
 
 			if err := r.pool.Stop(); err != nil {
-				r.logger.Error("failed to stop pool", "err", err)
+				r.Logger.Error("failed to stop pool", "err", err)
 			}
 
-			r.blockSync.UnSet()
-
 			if r.consReactor != nil {
-				r.consReactor.SwitchToConsensus(ctx, state, blocksSynced > 0 || stateSynced)
+				r.consReactor.SwitchToConsensus(state, blocksSynced > 0 || stateSynced)
 			}
 
 			break FOR_LOOP
@@ -527,7 +514,7 @@ FOR_LOOP:
 			err := state.Validators.VerifyCommitLight(chainID, firstID, first.Height, second.LastCommit)
 			if err != nil {
 				err = fmt.Errorf("invalid last commit: %w", err)
-				r.logger.Error(
+				r.Logger.Error(
 					err.Error(),
 					"last_commit", second.LastCommit,
 					"block_id", firstID,
@@ -537,20 +524,16 @@ FOR_LOOP:
 				// NOTE: We've already removed the peer's request, but we still need
 				// to clean up the rest.
 				peerID := r.pool.RedoRequest(first.Height)
-				if serr := r.blockSyncCh.SendError(ctx, p2p.PeerError{
+				r.blockchainCh.Error <- p2p.PeerError{
 					NodeID: peerID,
 					Err:    err,
-				}); serr != nil {
-					break FOR_LOOP
 				}
 
 				peerID2 := r.pool.RedoRequest(second.Height)
 				if peerID2 != peerID {
-					if serr := r.blockSyncCh.SendError(ctx, p2p.PeerError{
+					r.blockchainCh.Error <- p2p.PeerError{
 						NodeID: peerID2,
 						Err:    err,
-					}); serr != nil {
-						break FOR_LOOP
 					}
 				}
 
@@ -565,20 +548,18 @@ FOR_LOOP:
 
 				// TODO: Same thing for app - but we would need a way to get the hash
 				// without persisting the state.
-				state, err = r.blockExec.ApplyBlock(ctx, state, firstID, first)
+				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))
 				}
 
-				r.metrics.RecordConsMetrics(first)
-
 				blocksSynced++
 
 				if blocksSynced%100 == 0 {
 					lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
-					r.logger.Info(
-						"block sync rate",
+					r.Logger.Info(
+						"fast sync rate",
 						"height", r.pool.height,
 						"max_peer_height", r.pool.MaxPeerHeight(),
 						"blocks/s", lastRate,
@@ -590,38 +571,8 @@ FOR_LOOP:
 
 			continue FOR_LOOP
 
-		case <-ctx.Done():
-			break FOR_LOOP
-		case <-r.pool.exitedCh:
+		case <-r.closeCh:
 			break FOR_LOOP
 		}
 	}
 }
-
-func (r *Reactor) GetMaxPeerBlockHeight() int64 {
-	return r.pool.MaxPeerHeight()
-}
-
-func (r *Reactor) GetTotalSyncedTime() time.Duration {
-	if !r.blockSync.IsSet() || r.syncStartTime.IsZero() {
-		return time.Duration(0)
-	}
-	return time.Since(r.syncStartTime)
-}
-
-func (r *Reactor) GetRemainingSyncTime() time.Duration {
-	if !r.blockSync.IsSet() {
-		return time.Duration(0)
-	}
-
-	targetSyncs := r.pool.targetSyncBlocks()
-	currentSyncs := r.store.Height() - r.pool.startHeight + 1
-	lastSyncRate := r.pool.getLastSyncRate()
-	if currentSyncs < 0 || lastSyncRate < 0.001 {
-		return time.Duration(0)
-	}
-
-	remain := float64(targetSyncs-currentSyncs) / lastSyncRate
-
-	return time.Duration(int64(remain * float64(time.Second)))
-}

blockchain/v0/reactor_test.go

@@ -1,48 +1,43 @@
-package blocksync
+package v0
 
 import (
-	"context"
 	"os"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/require"
-	dbm "github.com/tendermint/tm-db"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/consensus"
-	"github.com/tendermint/tendermint/internal/mempool/mock"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/p2ptest"
-	"github.com/tendermint/tendermint/internal/proxy"
-	sm "github.com/tendermint/tendermint/internal/state"
-	sf "github.com/tendermint/tendermint/internal/state/test/factory"
-	"github.com/tendermint/tendermint/internal/store"
+	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
+	"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   []types.NodeID
+	nodes   []p2p.NodeID
 
-	reactors map[types.NodeID]*Reactor
-	app      map[types.NodeID]proxy.AppConns
+	reactors map[p2p.NodeID]*Reactor
+	app      map[p2p.NodeID]proxy.AppConns
 
-	blockSyncChannels map[types.NodeID]*p2p.Channel
-	peerChans         map[types.NodeID]chan p2p.PeerUpdate
-	peerUpdates       map[types.NodeID]*p2p.PeerUpdates
+	blockchainChannels map[p2p.NodeID]*p2p.Channel
+	peerChans          map[p2p.NodeID]chan p2p.PeerUpdate
+	peerUpdates        map[p2p.NodeID]*p2p.PeerUpdates
 
-	blockSync bool
+	fastSync bool
 }
 
 func setup(
-	ctx context.Context,
 	t *testing.T,
 	genDoc *types.GenesisDoc,
 	privVal types.PrivValidator,
@@ -51,41 +46,38 @@ func setup(
 ) *reactorTestSuite {
 	t.Helper()
 
-	var cancel context.CancelFunc
-	ctx, cancel = context.WithCancel(ctx)
-
 	numNodes := len(maxBlockHeights)
 	require.True(t, numNodes >= 1,
 		"must specify at least one block height (nodes)")
 
 	rts := &reactorTestSuite{
-		logger:            log.TestingLogger().With("module", "block_sync", "testCase", t.Name()),
-		network:           p2ptest.MakeNetwork(ctx, t, p2ptest.NetworkOptions{NumNodes: numNodes}),
-		nodes:             make([]types.NodeID, 0, numNodes),
-		reactors:          make(map[types.NodeID]*Reactor, numNodes),
-		app:               make(map[types.NodeID]proxy.AppConns, numNodes),
-		blockSyncChannels: make(map[types.NodeID]*p2p.Channel, numNodes),
-		peerChans:         make(map[types.NodeID]chan p2p.PeerUpdate, numNodes),
-		peerUpdates:       make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
-		blockSync:         true,
+		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: BlockSyncChannel, MessageType: new(bcproto.Message)}
-	rts.blockSyncChannels = rts.network.MakeChannelsNoCleanup(ctx, t, chDesc)
+	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(ctx, t, nodeID, genDoc, privVal, maxBlockHeights[i])
+		rts.addNode(t, nodeID, genDoc, privVal, maxBlockHeights[i])
 		i++
 	}
 
 	t.Cleanup(func() {
-		cancel()
 		for _, nodeID := range rts.nodes {
-			if rts.reactors[nodeID].IsRunning() {
-				rts.reactors[nodeID].Wait()
-				rts.app[nodeID].Wait()
+			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())
 			}
 		}
@@ -94,30 +86,28 @@ func setup(
 	return rts
 }
 
-func (rts *reactorTestSuite) addNode(
-	ctx context.Context,
-	t *testing.T,
-	nodeID types.NodeID,
+func (rts *reactorTestSuite) addNode(t *testing.T,
+	nodeID p2p.NodeID,
 	genDoc *types.GenesisDoc,
 	privVal types.PrivValidator,
 	maxBlockHeight int64,
 ) {
 	t.Helper()
 
-	logger := log.TestingLogger()
-
 	rts.nodes = append(rts.nodes, nodeID)
-	rts.app[nodeID] = proxy.NewAppConns(abciclient.NewLocalCreator(&abci.BaseApplication{}), logger, proxy.NopMetrics())
-	require.NoError(t, rts.app[nodeID].Start(ctx))
+	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 := sm.MakeGenesisState(genDoc)
+	state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
 	require.NoError(t, err)
-	require.NoError(t, stateStore.Save(state))
+
+	db := dbm.NewMemDB()
+	stateStore = sm.NewStore(db)
 
 	blockExec := sm.NewBlockExecutor(
 		stateStore,
@@ -125,8 +115,8 @@ func (rts *reactorTestSuite) addNode(
 		rts.app[nodeID].Consensus(),
 		mock.Mempool{},
 		sm.EmptyEvidencePool{},
-		blockStore,
 	)
+	require.NoError(t, stateStore.Save(state))
 
 	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
 		lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
@@ -152,11 +142,11 @@ func (rts *reactorTestSuite) addNode(
 			)
 		}
 
-		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)
+		thisBlock := makeBlock(blockHeight, state, lastCommit)
 		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
-		state, err = blockExec.ApplyBlock(ctx, state, blockID, thisBlock)
+		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
 		require.NoError(t, err)
 
 		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
@@ -164,26 +154,25 @@ func (rts *reactorTestSuite) addNode(
 
 	rts.peerChans[nodeID] = make(chan p2p.PeerUpdate)
 	rts.peerUpdates[nodeID] = p2p.NewPeerUpdates(rts.peerChans[nodeID], 1)
-	rts.network.Nodes[nodeID].PeerManager.Register(ctx, rts.peerUpdates[nodeID])
+	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.blockSyncChannels[nodeID],
+		rts.blockchainChannels[nodeID],
 		rts.peerUpdates[nodeID],
-		rts.blockSync,
-		consensus.NopMetrics())
+		rts.fastSync)
 	require.NoError(t, err)
 
-	require.NoError(t, rts.reactors[nodeID].Start(ctx))
+	require.NoError(t, rts.reactors[nodeID].Start())
 	require.True(t, rts.reactors[nodeID].IsRunning())
 }
 
-func (rts *reactorTestSuite) start(ctx context.Context, t *testing.T) {
+func (rts *reactorTestSuite) start(t *testing.T) {
 	t.Helper()
-	rts.network.Start(ctx, t)
+	rts.network.Start(t)
 	require.Len(t,
 		rts.network.RandomNode().PeerManager.Peers(),
 		len(rts.nodes)-1,
@@ -191,21 +180,17 @@ func (rts *reactorTestSuite) start(ctx context.Context, t *testing.T) {
 }
 
 func TestReactor_AbruptDisconnect(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	config := cfg.ResetTestRoot("blockchain_reactor_test")
+	defer os.RemoveAll(config.RootDir)
 
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
-	require.NoError(t, err)
-	defer os.RemoveAll(cfg.RootDir)
-
-	genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
 	maxBlockHeight := int64(64)
 
-	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
+	rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
 
 	require.Equal(t, maxBlockHeight, rts.reactors[rts.nodes[0]].store.Height())
 
-	rts.start(ctx, t)
+	rts.start(t)
 
 	secondaryPool := rts.reactors[rts.nodes[1]].pool
 
@@ -226,53 +211,21 @@ func TestReactor_AbruptDisconnect(t *testing.T) {
 		Status: p2p.PeerStatusDown,
 		NodeID: rts.nodes[0],
 	}
-	rts.network.Nodes[rts.nodes[1]].PeerManager.Disconnected(ctx, rts.nodes[0])
-}
-
-func TestReactor_SyncTime(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
-	require.NoError(t, err)
-	defer os.RemoveAll(cfg.RootDir)
-
-	genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30)
-	maxBlockHeight := int64(101)
-
-	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
-	require.Equal(t, maxBlockHeight, rts.reactors[rts.nodes[0]].store.Height())
-	rts.start(ctx, t)
-
-	require.Eventually(
-		t,
-		func() bool {
-			return rts.reactors[rts.nodes[1]].GetRemainingSyncTime() > time.Nanosecond &&
-				rts.reactors[rts.nodes[1]].pool.getLastSyncRate() > 0.001
-		},
-		10*time.Second,
-		10*time.Millisecond,
-		"expected node to be partially synced",
-	)
+	require.NoError(t, rts.network.Nodes[rts.nodes[1]].PeerManager.Disconnected(rts.nodes[0]))
 }
 
 func TestReactor_NoBlockResponse(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	config := cfg.ResetTestRoot("blockchain_reactor_test")
+	defer os.RemoveAll(config.RootDir)
 
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
-	require.NoError(t, err)
-
-	defer os.RemoveAll(cfg.RootDir)
-
-	genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
 	maxBlockHeight := int64(65)
 
-	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
+	rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0)
 
 	require.Equal(t, maxBlockHeight, rts.reactors[rts.nodes[0]].store.Height())
 
-	rts.start(ctx, t)
+	rts.start(t)
 
 	testCases := []struct {
 		height   int64
@@ -309,21 +262,17 @@ func TestReactor_BadBlockStopsPeer(t *testing.T) {
 	// See: https://github.com/tendermint/tendermint/issues/6005
 	t.SkipNow()
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	cfg, err := config.ResetTestRoot("block_sync_reactor_test")
-	require.NoError(t, err)
-	defer os.RemoveAll(cfg.RootDir)
+	config := cfg.ResetTestRoot("blockchain_reactor_test")
+	defer os.RemoveAll(config.RootDir)
 
 	maxBlockHeight := int64(48)
-	genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
 
-	rts := setup(ctx, t, genDoc, privVals[0], []int64{maxBlockHeight, 0, 0, 0, 0}, 1000)
+	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(ctx, t)
+	rts.start(t)
 
 	require.Eventually(
 		t,
@@ -351,12 +300,12 @@ func TestReactor_BadBlockStopsPeer(t *testing.T) {
 	//
 	// XXX: This causes a potential race condition.
 	// See: https://github.com/tendermint/tendermint/issues/6005
-	otherGenDoc, otherPrivVals := factory.RandGenesisDoc(cfg, 1, false, 30)
-	newNode := rts.network.MakeNode(ctx, t, p2ptest.NodeOptions{
+	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(ctx, t, newNode.NodeID, otherGenDoc, otherPrivVals[0], maxBlockHeight)
+	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)

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

@@ -0,0 +1,42 @@
+/*
+Package Behavior provides a mechanism for reactors to report behavior of peers.
+
+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 behaviors a reactor can report.
+
+1. bad message
+
+type badMessage struct {
+	explanation string
+}
+
+This message will request the peer be stopped for an error
+
+2. message out of order
+
+type messageOutOfOrder struct {
+	explanation string
+}
+
+This message will request the peer be stopped for an error
+
+3. consesnsus Vote
+
+type consensusVote struct {
+	explanation string
+}
+
+This message will request the peer be marked as good
+
+4. block part
+
+type blockPart struct {
+	explanation string
+}
+
+This message will request the peer be marked as good
+
+*/
+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

@@ -0,0 +1,86 @@
+package behavior
+
+import (
+	"errors"
+
+	tmsync "github.com/tendermint/tendermint/libs/sync"
+	"github.com/tendermint/tendermint/p2p"
+)
+
+// Reporter provides an interface for reactors to report the behavior
+// of peers synchronously to other components.
+type Reporter interface {
+	Report(behavior PeerBehavior) error
+}
+
+// SwitchReporter reports peer behavior to an internal Switch.
+type SwitchReporter struct {
+	sw *p2p.Switch
+}
+
+// NewSwitchReporter return a new SwitchReporter instance which wraps the Switch.
+func NewSwitchReporter(sw *p2p.Switch) *SwitchReporter {
+	return &SwitchReporter{
+		sw: sw,
+	}
+}
+
+// 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 := behavior.reason.(type) {
+	case consensusVote, blockPart:
+		spbr.sw.MarkPeerAsGood(peer)
+	case badMessage:
+		spbr.sw.StopPeerForError(peer, reason.explanation)
+	case messageOutOfOrder:
+		spbr.sw.StopPeerForError(peer, reason.explanation)
+	default:
+		return errors.New("unknown reason reported")
+	}
+
+	return nil
+}
+
+// MockReporter is a concrete implementation of the Reporter
+// interface used in reactor tests to ensure reactors report the correct
+// behavior in manufactured scenarios.
+type MockReporter struct {
+	mtx tmsync.RWMutex
+	pb  map[p2p.NodeID][]PeerBehavior
+}
+
+// NewMockReporter returns a Reporter which records all reported
+// behaviors in memory.
+func NewMockReporter() *MockReporter {
+	return &MockReporter{
+		pb: map[p2p.NodeID][]PeerBehavior{},
+	}
+}
+
+// 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[behavior.peerID] = append(mpbr.pb[behavior.peerID], behavior)
+
+	return nil
+}
+
+// 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([]PeerBehavior, len(items))
+		copy(result, items)
+
+		return result
+	}
+
+	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/metrics.go

@@ -0,0 +1,125 @@
+package v2
+
+import (
+	"github.com/go-kit/kit/metrics"
+	"github.com/go-kit/kit/metrics/discard"
+	"github.com/go-kit/kit/metrics/prometheus"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	// MetricsSubsystem is a subsystem shared by all metrics exposed by this
+	// package.
+	MetricsSubsystem = "blockchain"
+)
+
+// Metrics contains metrics exposed by this package.
+type Metrics struct {
+	// events_in
+	EventsIn metrics.Counter
+	// events_in
+	EventsHandled metrics.Counter
+	// events_out
+	EventsOut metrics.Counter
+	// errors_in
+	ErrorsIn metrics.Counter
+	// errors_handled
+	ErrorsHandled metrics.Counter
+	// errors_out
+	ErrorsOut metrics.Counter
+	// events_shed
+	EventsShed metrics.Counter
+	// events_sent
+	EventsSent metrics.Counter
+	// errors_sent
+	ErrorsSent metrics.Counter
+	// errors_shed
+	ErrorsShed metrics.Counter
+}
+
+// PrometheusMetrics returns metrics for in and out events, errors, etc. handled by routines.
+// Can we burn in the routine name here?
+func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics {
+	labels := []string{}
+	for i := 0; i < len(labelsAndValues); i += 2 {
+		labels = append(labels, labelsAndValues[i])
+	}
+	return &Metrics{
+		EventsIn: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "events_in",
+			Help:      "Events read from the channel.",
+		}, labels).With(labelsAndValues...),
+		EventsHandled: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "events_handled",
+			Help:      "Events handled",
+		}, labels).With(labelsAndValues...),
+		EventsOut: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "events_out",
+			Help:      "Events output from routine.",
+		}, labels).With(labelsAndValues...),
+		ErrorsIn: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "errors_in",
+			Help:      "Errors read from the channel.",
+		}, labels).With(labelsAndValues...),
+		ErrorsHandled: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "errors_handled",
+			Help:      "Errors handled.",
+		}, labels).With(labelsAndValues...),
+		ErrorsOut: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "errors_out",
+			Help:      "Errors output from routine.",
+		}, labels).With(labelsAndValues...),
+		ErrorsSent: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "errors_sent",
+			Help:      "Errors sent to routine.",
+		}, labels).With(labelsAndValues...),
+		ErrorsShed: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "errors_shed",
+			Help:      "Errors dropped from sending.",
+		}, labels).With(labelsAndValues...),
+		EventsSent: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "events_sent",
+			Help:      "Events sent to routine.",
+		}, labels).With(labelsAndValues...),
+		EventsShed: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "events_shed",
+			Help:      "Events dropped from sending.",
+		}, labels).With(labelsAndValues...),
+	}
+}
+
+// NopMetrics returns no-op Metrics.
+func NopMetrics() *Metrics {
+	return &Metrics{
+		EventsIn:      discard.NewCounter(),
+		EventsHandled: discard.NewCounter(),
+		EventsOut:     discard.NewCounter(),
+		ErrorsIn:      discard.NewCounter(),
+		ErrorsHandled: discard.NewCounter(),
+		ErrorsOut:     discard.NewCounter(),
+		EventsShed:    discard.NewCounter(),
+		EventsSent:    discard.NewCounter(),
+		ErrorsSent:    discard.NewCounter(),
+		ErrorsShed:    discard.NewCounter(),
+	}
+}

blockchain/v2/processor.go

@@ -0,0 +1,192 @@
+package v2
+
+import (
+	"fmt"
+
+	"github.com/tendermint/tendermint/p2p"
+	tmState "github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/types"
+)
+
+// Events generated by the processor:
+// block execution failure, event will indicate the peer(s) that caused the error
+type pcBlockVerificationFailure struct {
+	priorityNormal
+	height       int64
+	firstPeerID  p2p.NodeID
+	secondPeerID p2p.NodeID
+}
+
+func (e pcBlockVerificationFailure) String() string {
+	return fmt.Sprintf("pcBlockVerificationFailure{%d 1st peer: %v, 2nd peer: %v}",
+		e.height, e.firstPeerID, e.secondPeerID)
+}
+
+// successful block execution
+type pcBlockProcessed struct {
+	priorityNormal
+	height int64
+	peerID p2p.NodeID
+}
+
+func (e pcBlockProcessed) String() string {
+	return fmt.Sprintf("pcBlockProcessed{%d peer: %v}", e.height, e.peerID)
+}
+
+// processor has finished
+type pcFinished struct {
+	priorityNormal
+	blocksSynced int
+	tmState      tmState.State
+}
+
+func (p pcFinished) Error() string {
+	return "finished"
+}
+
+type queueItem struct {
+	block  *types.Block
+	peerID p2p.NodeID
+}
+
+type blockQueue map[int64]queueItem
+
+type pcState struct {
+	// blocks waiting to be processed
+	queue blockQueue
+
+	// draining indicates that the next rProcessBlock event with a queue miss constitutes completion
+	draining bool
+
+	// the number of blocks successfully synced by the processor
+	blocksSynced int
+
+	// the processorContext which contains the processor dependencies
+	context processorContext
+}
+
+func (state *pcState) String() string {
+	return fmt.Sprintf("height: %d queue length: %d draining: %v blocks synced: %d",
+		state.height(), len(state.queue), state.draining, state.blocksSynced)
+}
+
+// newPcState returns a pcState initialized with the last verified block enqueued
+func newPcState(context processorContext) *pcState {
+	return &pcState{
+		queue:        blockQueue{},
+		draining:     false,
+		blocksSynced: 0,
+		context:      context,
+	}
+}
+
+// nextTwo returns the next two unverified blocks
+func (state *pcState) nextTwo() (queueItem, queueItem, error) {
+	if first, ok := state.queue[state.height()+1]; ok {
+		if second, ok := state.queue[state.height()+2]; ok {
+			return first, second, nil
+		}
+	}
+	return queueItem{}, queueItem{}, fmt.Errorf("not found")
+}
+
+// synced returns true when at most the last verified block remains in the queue
+func (state *pcState) synced() bool {
+	return len(state.queue) <= 1
+}
+
+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)",
+			height, block.Hash(), peerID, item.block.Hash(), item.peerID))
+	}
+
+	state.queue[height] = queueItem{block: block, peerID: peerID}
+}
+
+func (state *pcState) height() int64 {
+	return state.context.tmState().LastBlockHeight
+}
+
+// purgePeer moves all unprocessed blocks from the queue
+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 {
+			delete(state.queue, height)
+		}
+	}
+}
+
+// handle processes FSM events
+func (state *pcState) handle(event Event) (Event, error) {
+	switch event := event.(type) {
+	case bcResetState:
+		state.context.setState(event.state)
+		return noOp, nil
+
+	case scFinishedEv:
+		if state.synced() {
+			return pcFinished{tmState: state.context.tmState(), blocksSynced: state.blocksSynced}, nil
+		}
+		state.draining = true
+		return noOp, nil
+
+	case scPeerError:
+		state.purgePeer(event.peerID)
+		return noOp, nil
+
+	case scBlockReceived:
+		if event.block == nil {
+			return noOp, nil
+		}
+
+		// enqueue block if height is higher than state height, else ignore it
+		if event.block.Height > state.height() {
+			state.enqueue(event.peerID, event.block, event.block.Height)
+		}
+		return noOp, nil
+
+	case rProcessBlock:
+		tmState := state.context.tmState()
+		firstItem, secondItem, err := state.nextTwo()
+		if err != nil {
+			if state.draining {
+				return pcFinished{tmState: tmState, blocksSynced: state.blocksSynced}, nil
+			}
+			return noOp, nil
+		}
+
+		var (
+			first, second = firstItem.block, secondItem.block
+			firstParts    = first.MakePartSet(types.BlockPartSizeBytes)
+			firstID       = types.BlockID{Hash: first.Hash(), PartSetHeader: firstParts.Header()}
+		)
+
+		// verify if +second+ last commit "confirms" +first+ block
+		err = state.context.verifyCommit(tmState.ChainID, firstID, first.Height, second.LastCommit)
+		if err != nil {
+			state.purgePeer(firstItem.peerID)
+			if firstItem.peerID != secondItem.peerID {
+				state.purgePeer(secondItem.peerID)
+			}
+			return pcBlockVerificationFailure{
+					height: first.Height, firstPeerID: firstItem.peerID, secondPeerID: secondItem.peerID},
+				nil
+		}
+
+		state.context.saveBlock(first, firstParts, second.LastCommit)
+
+		if err := state.context.applyBlock(firstID, first); err != nil {
+			panic(fmt.Sprintf("failed to process committed block (%d:%X): %v", first.Height, first.Hash(), err))
+		}
+
+		delete(state.queue, first.Height)
+		state.blocksSynced++
+
+		return pcBlockProcessed{height: first.Height, peerID: firstItem.peerID}, nil
+	}
+
+	return noOp, nil
+}

blockchain/v2/processor_context.go

@@ -0,0 +1,100 @@
+package v2
+
+import (
+	"fmt"
+
+	"github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/types"
+)
+
+type processorContext interface {
+	applyBlock(blockID types.BlockID, block *types.Block) error
+	verifyCommit(chainID string, blockID types.BlockID, height int64, commit *types.Commit) error
+	saveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit)
+	tmState() state.State
+	setState(state.State)
+}
+
+type pContext struct {
+	store   blockStore
+	applier blockApplier
+	state   state.State
+}
+
+func newProcessorContext(st blockStore, ex blockApplier, s state.State) *pContext {
+	return &pContext{
+		store:   st,
+		applier: ex,
+		state:   s,
+	}
+}
+
+func (pc *pContext) applyBlock(blockID types.BlockID, block *types.Block) error {
+	newState, _, err := pc.applier.ApplyBlock(pc.state, blockID, block)
+	pc.state = newState
+	return err
+}
+
+func (pc pContext) tmState() state.State {
+	return pc.state
+}
+
+func (pc *pContext) setState(state state.State) {
+	pc.state = state
+}
+
+func (pc pContext) verifyCommit(chainID string, blockID types.BlockID, height int64, commit *types.Commit) error {
+	return pc.state.Validators.VerifyCommitLight(chainID, blockID, height, commit)
+}
+
+func (pc *pContext) saveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
+	pc.store.SaveBlock(block, blockParts, seenCommit)
+}
+
+type mockPContext struct {
+	applicationBL  []int64
+	verificationBL []int64
+	state          state.State
+}
+
+func newMockProcessorContext(
+	state state.State,
+	verificationBlackList []int64,
+	applicationBlackList []int64) *mockPContext {
+	return &mockPContext{
+		applicationBL:  applicationBlackList,
+		verificationBL: verificationBlackList,
+		state:          state,
+	}
+}
+
+func (mpc *mockPContext) applyBlock(blockID types.BlockID, block *types.Block) error {
+	for _, h := range mpc.applicationBL {
+		if h == block.Height {
+			return fmt.Errorf("generic application error")
+		}
+	}
+	mpc.state.LastBlockHeight = block.Height
+	return nil
+}
+
+func (mpc *mockPContext) verifyCommit(chainID string, blockID types.BlockID, height int64, commit *types.Commit) error {
+	for _, h := range mpc.verificationBL {
+		if h == height {
+			return fmt.Errorf("generic verification error")
+		}
+	}
+	return nil
+}
+
+func (mpc *mockPContext) saveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
+
+}
+
+func (mpc *mockPContext) setState(state state.State) {
+	mpc.state = state
+}
+
+func (mpc *mockPContext) tmState() state.State {
+	return mpc.state
+}

blockchain/v2/processor_test.go

@@ -0,0 +1,306 @@
+package v2
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/tendermint/tendermint/p2p"
+	tmState "github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/types"
+)
+
+// pcBlock is a test helper structure with simple types. Its purpose is to help with test readability.
+type pcBlock struct {
+	pid    string
+	height int64
+}
+
+// params is a test structure used to create processor state.
+type params struct {
+	height       int64
+	items        []pcBlock
+	blocksSynced int
+	verBL        []int64
+	appBL        []int64
+	draining     bool
+}
+
+// makePcBlock makes an empty block.
+func makePcBlock(height int64) *types.Block {
+	return &types.Block{Header: types.Header{Height: height}}
+}
+
+// makeState takes test parameters and creates a specific processor state.
+func makeState(p *params) *pcState {
+	var (
+		tmState = tmState.State{LastBlockHeight: p.height}
+		context = newMockProcessorContext(tmState, p.verBL, p.appBL)
+	)
+	state := newPcState(context)
+
+	for _, item := range p.items {
+		state.enqueue(p2p.NodeID(item.pid), makePcBlock(item.height), item.height)
+	}
+
+	state.blocksSynced = p.blocksSynced
+	state.draining = p.draining
+	return state
+}
+
+func mBlockResponse(peerID p2p.NodeID, height int64) scBlockReceived {
+	return scBlockReceived{
+		peerID: peerID,
+		block:  makePcBlock(height),
+	}
+}
+
+type pcFsmMakeStateValues struct {
+	currentState  *params
+	event         Event
+	wantState     *params
+	wantNextEvent Event
+	wantErr       error
+	wantPanic     bool
+}
+
+type testFields struct {
+	name  string
+	steps []pcFsmMakeStateValues
+}
+
+func executeProcessorTests(t *testing.T, tests []testFields) {
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			var state *pcState
+			for _, step := range tt.steps {
+				defer func() {
+					r := recover()
+					if (r != nil) != step.wantPanic {
+						t.Errorf("recover = %v, wantPanic = %v", r, step.wantPanic)
+					}
+				}()
+
+				// First step must always initialize the currentState as state.
+				if step.currentState != nil {
+					state = makeState(step.currentState)
+				}
+				if state == nil {
+					panic("Bad (initial?) step")
+				}
+
+				nextEvent, err := state.handle(step.event)
+				t.Log(state)
+				assert.Equal(t, step.wantErr, err)
+				assert.Equal(t, makeState(step.wantState), state)
+				assert.Equal(t, step.wantNextEvent, nextEvent)
+				// Next step may use the wantedState as their currentState.
+				state = makeState(step.wantState)
+			}
+		})
+	}
+}
+
+func TestRProcessPeerError(t *testing.T) {
+	tests := []testFields{
+		{
+			name: "error for existing peer",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState:  &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}},
+					event:         scPeerError{peerID: "P2"},
+					wantState:     &params{items: []pcBlock{{"P1", 1}}},
+					wantNextEvent: noOp,
+				},
+			},
+		},
+		{
+			name: "error for unknown peer",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState:  &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}},
+					event:         scPeerError{peerID: "P3"},
+					wantState:     &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}},
+					wantNextEvent: noOp,
+				},
+			},
+		},
+	}
+
+	executeProcessorTests(t, tests)
+}
+
+func TestPcBlockResponse(t *testing.T) {
+	tests := []testFields{
+		{
+			name: "add one block",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{}, event: mBlockResponse("P1", 1),
+					wantState: &params{items: []pcBlock{{"P1", 1}}}, wantNextEvent: noOp,
+				},
+			},
+		},
+
+		{
+			name: "add two blocks",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{}, event: mBlockResponse("P1", 3),
+					wantState: &params{items: []pcBlock{{"P1", 3}}}, wantNextEvent: noOp,
+				},
+				{ // use previous wantState as currentState,
+					event:     mBlockResponse("P1", 4),
+					wantState: &params{items: []pcBlock{{"P1", 3}, {"P1", 4}}}, wantNextEvent: noOp,
+				},
+			},
+		},
+	}
+
+	executeProcessorTests(t, tests)
+}
+
+func TestRProcessBlockSuccess(t *testing.T) {
+	tests := []testFields{
+		{
+			name: "noop - no blocks over current height",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{}, event: rProcessBlock{},
+					wantState: &params{}, wantNextEvent: noOp,
+				},
+			},
+		},
+		{
+			name: "noop - high new blocks",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{height: 5, items: []pcBlock{{"P1", 30}, {"P2", 31}}}, event: rProcessBlock{},
+					wantState: &params{height: 5, items: []pcBlock{{"P1", 30}, {"P2", 31}}}, wantNextEvent: noOp,
+				},
+			},
+		},
+		{
+			name: "blocks H+1 and H+2 present",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}}, event: rProcessBlock{},
+					wantState:     &params{height: 1, items: []pcBlock{{"P2", 2}}, blocksSynced: 1},
+					wantNextEvent: pcBlockProcessed{height: 1, peerID: "P1"},
+				},
+			},
+		},
+		{
+			name: "blocks H+1 and H+2 present after draining",
+			steps: []pcFsmMakeStateValues{
+				{ // some contiguous blocks - on stop check draining is set
+					currentState:  &params{items: []pcBlock{{"P1", 1}, {"P2", 2}, {"P1", 4}}},
+					event:         scFinishedEv{},
+					wantState:     &params{items: []pcBlock{{"P1", 1}, {"P2", 2}, {"P1", 4}}, draining: true},
+					wantNextEvent: noOp,
+				},
+				{
+					event:         rProcessBlock{},
+					wantState:     &params{height: 1, items: []pcBlock{{"P2", 2}, {"P1", 4}}, blocksSynced: 1, draining: true},
+					wantNextEvent: pcBlockProcessed{height: 1, peerID: "P1"},
+				},
+				{ // finish when H+1 or/and H+2 are missing
+					event:         rProcessBlock{},
+					wantState:     &params{height: 1, items: []pcBlock{{"P2", 2}, {"P1", 4}}, blocksSynced: 1, draining: true},
+					wantNextEvent: pcFinished{tmState: tmState.State{LastBlockHeight: 1}, blocksSynced: 1},
+				},
+			},
+		},
+	}
+
+	executeProcessorTests(t, tests)
+}
+
+func TestRProcessBlockFailures(t *testing.T) {
+	tests := []testFields{
+		{
+			name: "blocks H+1 and H+2 present from different peers - H+1 verification fails ",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}, verBL: []int64{1}}, event: rProcessBlock{},
+					wantState:     &params{items: []pcBlock{}, verBL: []int64{1}},
+					wantNextEvent: pcBlockVerificationFailure{height: 1, firstPeerID: "P1", secondPeerID: "P2"},
+				},
+			},
+		},
+		{
+			name: "blocks H+1 and H+2 present from same peer - H+1 applyBlock fails ",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}, appBL: []int64{1}}, event: rProcessBlock{},
+					wantState: &params{items: []pcBlock{}, appBL: []int64{1}}, wantPanic: true,
+				},
+			},
+		},
+		{
+			name: "blocks H+1 and H+2 present from same peers - H+1 verification fails ",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{height: 0, items: []pcBlock{{"P1", 1}, {"P1", 2}, {"P2", 3}},
+						verBL: []int64{1}}, event: rProcessBlock{},
+					wantState:     &params{height: 0, items: []pcBlock{{"P2", 3}}, verBL: []int64{1}},
+					wantNextEvent: pcBlockVerificationFailure{height: 1, firstPeerID: "P1", secondPeerID: "P1"},
+				},
+			},
+		},
+		{
+			name: "blocks H+1 and H+2 present from different peers - H+1 applyBlock fails ",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}, {"P2", 3}}, appBL: []int64{1}},
+					event:        rProcessBlock{},
+					wantState:    &params{items: []pcBlock{{"P2", 3}}, appBL: []int64{1}}, wantPanic: true,
+				},
+			},
+		},
+	}
+
+	executeProcessorTests(t, tests)
+}
+
+func TestScFinishedEv(t *testing.T) {
+	tests := []testFields{
+		{
+			name: "no blocks",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{height: 100, items: []pcBlock{}, blocksSynced: 100}, event: scFinishedEv{},
+					wantState:     &params{height: 100, items: []pcBlock{}, blocksSynced: 100},
+					wantNextEvent: pcFinished{tmState: tmState.State{LastBlockHeight: 100}, blocksSynced: 100},
+				},
+			},
+		},
+		{
+			name: "maxHeight+1 block present",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{height: 100, items: []pcBlock{
+						{"P1", 101}}, blocksSynced: 100}, event: scFinishedEv{},
+					wantState:     &params{height: 100, items: []pcBlock{{"P1", 101}}, blocksSynced: 100},
+					wantNextEvent: pcFinished{tmState: tmState.State{LastBlockHeight: 100}, blocksSynced: 100},
+				},
+			},
+		},
+		{
+			name: "more blocks present",
+			steps: []pcFsmMakeStateValues{
+				{
+					currentState: &params{height: 100, items: []pcBlock{
+						{"P1", 101}, {"P1", 102}}, blocksSynced: 100}, event: scFinishedEv{},
+					wantState: &params{height: 100, items: []pcBlock{
+						{"P1", 101}, {"P1", 102}}, blocksSynced: 100, draining: true},
+					wantNextEvent: noOp,
+					wantErr:       nil,
+				},
+			},
+		},
+	}
+
+	executeProcessorTests(t, tests)
+}

blockchain/v2/reactor.go

@@ -0,0 +1,590 @@
+package v2
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	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"
+	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
+	"github.com/tendermint/tendermint/state"
+	"github.com/tendermint/tendermint/types"
+)
+
+const (
+	// chBufferSize is the buffer size of all event channels.
+	chBufferSize int = 1000
+)
+
+type blockStore interface {
+	LoadBlock(height int64) *types.Block
+	SaveBlock(*types.Block, *types.PartSet, *types.Commit)
+	Base() int64
+	Height() int64
+}
+
+// BlockchainReactor handles fast sync protocol.
+type BlockchainReactor struct {
+	p2p.BaseReactor
+
+	fastSync    bool // if true, enable fast sync on start
+	stateSynced bool // set to true when SwitchToFastSync is called by state sync
+	scheduler   *Routine
+	processor   *Routine
+	logger      log.Logger
+
+	mtx           tmsync.RWMutex
+	maxPeerHeight int64
+	syncHeight    int64
+	events        chan Event // non-nil during a fast sync
+
+	reporter behavior.Reporter
+	io       iIO
+	store    blockStore
+}
+
+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 behavior.Reporter,
+	blockApplier blockApplier, fastSync bool) *BlockchainReactor {
+	initHeight := state.LastBlockHeight + 1
+	if initHeight == 1 {
+		initHeight = state.InitialHeight
+	}
+	scheduler := newScheduler(initHeight, time.Now())
+	pContext := newProcessorContext(store, blockApplier, state)
+	// TODO: Fix naming to just newProcesssor
+	// newPcState requires a processorContext
+	processor := newPcState(pContext)
+
+	return &BlockchainReactor{
+		scheduler: newRoutine("scheduler", scheduler.handle, chBufferSize),
+		processor: newRoutine("processor", processor.handle, chBufferSize),
+		store:     store,
+		reporter:  reporter,
+		logger:    log.NewNopLogger(),
+		fastSync:  fastSync,
+	}
+}
+
+// NewBlockchainReactor creates a new reactor instance.
+func NewBlockchainReactor(
+	state state.State,
+	blockApplier blockApplier,
+	store blockStore,
+	fastSync bool) *BlockchainReactor {
+	reporter := behavior.NewMockReporter()
+	return newReactor(state, store, reporter, blockApplier, fastSync)
+}
+
+// SetSwitch implements Reactor interface.
+func (r *BlockchainReactor) SetSwitch(sw *p2p.Switch) {
+	r.Switch = sw
+	if sw != nil {
+		r.io = newSwitchIo(sw)
+	} else {
+		r.io = nil
+	}
+}
+
+func (r *BlockchainReactor) setMaxPeerHeight(height int64) {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+	if height > r.maxPeerHeight {
+		r.maxPeerHeight = height
+	}
+}
+
+func (r *BlockchainReactor) setSyncHeight(height int64) {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+	r.syncHeight = height
+}
+
+// SyncHeight returns the height to which the BlockchainReactor has synced.
+func (r *BlockchainReactor) SyncHeight() int64 {
+	r.mtx.RLock()
+	defer r.mtx.RUnlock()
+	return r.syncHeight
+}
+
+// SetLogger sets the logger of the reactor.
+func (r *BlockchainReactor) SetLogger(logger log.Logger) {
+	r.logger = logger
+	r.scheduler.setLogger(logger)
+	r.processor.setLogger(logger)
+}
+
+// Start implements cmn.Service interface
+func (r *BlockchainReactor) Start() error {
+	r.reporter = behavior.NewSwitchReporter(r.BaseReactor.Switch)
+	if r.fastSync {
+		err := r.startSync(nil)
+		if err != nil {
+			return fmt.Errorf("failed to start fast sync: %w", err)
+		}
+	}
+	return 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()
+	defer r.mtx.Unlock()
+	if r.events != nil {
+		return errors.New("fast sync already in progress")
+	}
+	r.events = make(chan Event, chBufferSize)
+	go r.scheduler.start()
+	go r.processor.start()
+	if state != nil {
+		<-r.scheduler.ready()
+		<-r.processor.ready()
+		r.scheduler.send(bcResetState{state: *state})
+		r.processor.send(bcResetState{state: *state})
+	}
+	go r.demux(r.events)
+	return nil
+}
+
+// endSync ends a fast sync
+func (r *BlockchainReactor) endSync() {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+	if r.events != nil {
+		close(r.events)
+	}
+	r.events = nil
+	r.scheduler.stop()
+	r.processor.stop()
+}
+
+// SwitchToFastSync is called by the state sync reactor when switching to fast sync.
+func (r *BlockchainReactor) SwitchToFastSync(state state.State) error {
+	r.stateSynced = true
+	state = state.Copy()
+	return r.startSync(&state)
+}
+
+// reactor generated ticker events:
+// ticker for cleaning peers
+type rTryPrunePeer struct {
+	priorityHigh
+	time time.Time
+}
+
+func (e rTryPrunePeer) String() string {
+	return fmt.Sprintf("rTryPrunePeer{%v}", e.time)
+}
+
+// ticker event for scheduling block requests
+type rTrySchedule struct {
+	priorityHigh
+	time time.Time
+}
+
+func (e rTrySchedule) String() string {
+	return fmt.Sprintf("rTrySchedule{%v}", e.time)
+}
+
+// ticker for block processing
+type rProcessBlock struct {
+	priorityNormal
+}
+
+func (e rProcessBlock) String() string {
+	return "rProcessBlock"
+}
+
+// reactor generated events based on blockchain related messages from peers:
+// blockResponse message received from a peer
+type bcBlockResponse struct {
+	priorityNormal
+	time   time.Time
+	peerID p2p.NodeID
+	size   int64
+	block  *types.Block
+}
+
+func (resp bcBlockResponse) String() string {
+	return fmt.Sprintf("bcBlockResponse{%d#%X (size: %d bytes) from %v at %v}",
+		resp.block.Height, resp.block.Hash(), resp.size, resp.peerID, resp.time)
+}
+
+// blockNoResponse message received from a peer
+type bcNoBlockResponse struct {
+	priorityNormal
+	time   time.Time
+	peerID p2p.NodeID
+	height int64
+}
+
+func (resp bcNoBlockResponse) String() string {
+	return fmt.Sprintf("bcNoBlockResponse{%v has no block at height %d at %v}",
+		resp.peerID, resp.height, resp.time)
+}
+
+// statusResponse message received from a peer
+type bcStatusResponse struct {
+	priorityNormal
+	time   time.Time
+	peerID p2p.NodeID
+	base   int64
+	height int64
+}
+
+func (resp bcStatusResponse) String() string {
+	return fmt.Sprintf("bcStatusResponse{%v is at height %d (base: %d) at %v}",
+		resp.peerID, resp.height, resp.base, resp.time)
+}
+
+// new peer is connected
+type bcAddNewPeer struct {
+	priorityNormal
+	peerID p2p.NodeID
+}
+
+func (resp bcAddNewPeer) String() string {
+	return fmt.Sprintf("bcAddNewPeer{%v}", resp.peerID)
+}
+
+// existing peer is removed
+type bcRemovePeer struct {
+	priorityHigh
+	peerID p2p.NodeID
+	reason interface{}
+}
+
+func (resp bcRemovePeer) String() string {
+	return fmt.Sprintf("bcRemovePeer{%v due to %v}", resp.peerID, resp.reason)
+}
+
+// resets the scheduler and processor state, e.g. following a switch from state syncing
+type bcResetState struct {
+	priorityHigh
+	state state.State
+}
+
+func (e bcResetState) String() string {
+	return fmt.Sprintf("bcResetState{%v}", e.state)
+}
+
+// Takes the channel as a parameter to avoid race conditions on r.events.
+func (r *BlockchainReactor) demux(events <-chan Event) {
+	var lastRate = 0.0
+	var lastHundred = time.Now()
+
+	var (
+		processBlockFreq = 20 * time.Millisecond
+		doProcessBlockCh = make(chan struct{}, 1)
+		doProcessBlockTk = time.NewTicker(processBlockFreq)
+	)
+	defer doProcessBlockTk.Stop()
+
+	var (
+		prunePeerFreq = 1 * time.Second
+		doPrunePeerCh = make(chan struct{}, 1)
+		doPrunePeerTk = time.NewTicker(prunePeerFreq)
+	)
+	defer doPrunePeerTk.Stop()
+
+	var (
+		scheduleFreq = 20 * time.Millisecond
+		doScheduleCh = make(chan struct{}, 1)
+		doScheduleTk = time.NewTicker(scheduleFreq)
+	)
+	defer doScheduleTk.Stop()
+
+	var (
+		statusFreq = 10 * time.Second
+		doStatusCh = make(chan struct{}, 1)
+		doStatusTk = time.NewTicker(statusFreq)
+	)
+	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 {
+		// Pacers: send at most per frequency but don't saturate
+		case <-doProcessBlockTk.C:
+			select {
+			case doProcessBlockCh <- struct{}{}:
+			default:
+			}
+		case <-doPrunePeerTk.C:
+			select {
+			case doPrunePeerCh <- struct{}{}:
+			default:
+			}
+		case <-doScheduleTk.C:
+			select {
+			case doScheduleCh <- struct{}{}:
+			default:
+			}
+		case <-doStatusTk.C:
+			select {
+			case doStatusCh <- struct{}{}:
+			default:
+			}
+
+		// Tickers: perform tasks periodically
+		case <-doScheduleCh:
+			r.scheduler.send(rTrySchedule{time: time.Now()})
+		case <-doPrunePeerCh:
+			r.scheduler.send(rTryPrunePeer{time: time.Now()})
+		case <-doProcessBlockCh:
+			r.processor.send(rProcessBlock{})
+		case <-doStatusCh:
+			if err := r.io.broadcastStatusRequest(); err != nil {
+				r.logger.Error("Error broadcasting status request", "err", err)
+			}
+
+		// Events from peers. Closing the channel signals event loop termination.
+		case event, ok := <-events:
+			if !ok {
+				r.logger.Info("Stopping event processing")
+				return
+			}
+			switch event := event.(type) {
+			case bcStatusResponse:
+				r.setMaxPeerHeight(event.height)
+				r.scheduler.send(event)
+			case bcAddNewPeer, bcRemovePeer, bcBlockResponse, bcNoBlockResponse:
+				r.scheduler.send(event)
+			default:
+				r.logger.Error("Received unexpected event", "event", fmt.Sprintf("%T", event))
+			}
+
+		// Incremental events from scheduler
+		case event := <-r.scheduler.next():
+			switch event := event.(type) {
+			case scBlockReceived:
+				r.processor.send(event)
+			case scPeerError:
+				r.processor.send(event)
+				if err := r.reporter.Report(behavior.BadMessage(event.peerID, "scPeerError")); err != nil {
+					r.logger.Error("Error reporting peer", "err", err)
+				}
+			case scBlockRequest:
+				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:
+				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 {
+					r.processor.send(scPeerError{peerID: peerID, reason: errors.New("peer was pruned")})
+				}
+				r.logger.Debug("Pruned peers", "count", len(event.peers))
+			case noOpEvent:
+			default:
+				r.logger.Error("Received unexpected scheduler event", "event", fmt.Sprintf("%T", event))
+			}
+
+		// Incremental events from processor
+		case event := <-r.processor.next():
+			switch event := event.(type) {
+			case pcBlockProcessed:
+				r.setSyncHeight(event.height)
+				if r.syncHeight%100 == 0 {
+					lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
+					r.logger.Info("Fast Sync Rate", "height", r.syncHeight,
+						"max_peer_height", r.maxPeerHeight, "blocks/s", lastRate)
+					lastHundred = time.Now()
+				}
+				r.scheduler.send(event)
+			case pcBlockVerificationFailure:
+				r.scheduler.send(event)
+			case pcFinished:
+				r.logger.Info("Fast sync complete, switching to consensus")
+				if !r.io.trySwitchToConsensus(event.tmState, event.blocksSynced > 0 || r.stateSynced) {
+					r.logger.Error("Failed to switch to consensus reactor")
+				}
+				r.endSync()
+				return
+			case noOpEvent:
+			default:
+				r.logger.Error("Received unexpected processor event", "event", fmt.Sprintf("%T", event))
+			}
+
+		// Terminal event from scheduler
+		case err := <-r.scheduler.final():
+			switch err {
+			case nil:
+				r.logger.Info("Scheduler stopped")
+			default:
+				r.logger.Error("Scheduler aborted with error", "err", err)
+			}
+
+		// Terminal event from processor
+		case err := <-r.processor.final():
+			switch err {
+			case nil:
+				r.logger.Info("Processor stopped")
+			default:
+				r.logger.Error("Processor aborted with error", "err", err)
+			}
+		}
+	}
+}
+
+// Stop implements cmn.Service interface.
+func (r *BlockchainReactor) Stop() error {
+	r.logger.Info("reactor stopping")
+	r.endSync()
+	r.logger.Info("reactor stopped")
+	return nil
+}
+
+// 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) {
+	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 := 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("received", "msg", msgProto)
+
+	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.Message_BlockRequest:
+		block := r.store.LoadBlock(msg.BlockRequest.Height)
+		if block != nil {
+			if err := r.io.sendBlockToPeer(block, src); err != nil {
+				logger.Error("Could not send block message to src peer", "err", err)
+			}
+		} else {
+			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.Message_StatusResponse:
+		r.mtx.RLock()
+		if r.events != nil {
+			r.events <- bcStatusResponse{
+				peerID: src.ID(),
+				base:   msg.StatusResponse.Base,
+				height: msg.StatusResponse.Height,
+			}
+		}
+		r.mtx.RUnlock()
+
+	case *bcproto.Message_BlockResponse:
+		bi, err := types.BlockFromProto(msg.BlockResponse.Block)
+		if err != nil {
+			logger.Error("error transitioning block from protobuf", "err", err)
+			_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
+			return
+		}
+		r.mtx.RLock()
+		if r.events != nil {
+			r.events <- bcBlockResponse{
+				peerID: src.ID(),
+				block:  bi,
+				size:   int64(len(msgBytes)),
+				time:   time.Now(),
+			}
+		}
+		r.mtx.RUnlock()
+
+	case *bcproto.Message_NoBlockResponse:
+		r.mtx.RLock()
+		if r.events != nil {
+			r.events <- bcNoBlockResponse{
+				peerID: src.ID(),
+				height: msg.NoBlockResponse.Height,
+				time:   time.Now(),
+			}
+		}
+		r.mtx.RUnlock()
+	}
+}
+
+// AddPeer implements Reactor interface
+func (r *BlockchainReactor) AddPeer(peer p2p.Peer) {
+	err := r.io.sendStatusResponse(r.store.Base(), r.store.Height(), peer)
+	if err != nil {
+		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 {
+		r.events <- bcAddNewPeer{peerID: peer.ID()}
+	}
+}
+
+// RemovePeer implements Reactor interface.
+func (r *BlockchainReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
+	r.mtx.RLock()
+	defer r.mtx.RUnlock()
+	if r.events != nil {
+		r.events <- bcRemovePeer{
+			peerID: peer.ID(),
+			reason: reason,
+		}
+	}
+}
+
+// GetChannels implements Reactor
+func (r *BlockchainReactor) GetChannels() []*p2p.ChannelDescriptor {
+	return []*p2p.ChannelDescriptor{
+		{
+			ID:                  BlockchainChannel,
+			Priority:            5,
+			SendQueueCapacity:   2000,
+			RecvBufferCapacity:  50 * 4096,
+			RecvMessageCapacity: bc.MaxMsgSize,
+		},
+	}
+}

blockchain/v2/reactor_test.go

@@ -0,0 +1,556 @@
+package v2
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"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/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"
+	"github.com/tendermint/tendermint/p2p"
+	"github.com/tendermint/tendermint/p2p/conn"
+	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"
+)
+
+type mockPeer struct {
+	service.Service
+	id p2p.NodeID
+}
+
+func (mp mockPeer) FlushStop()           {}
+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} }
+
+func (mp mockPeer) IsOutbound() bool   { return true }
+func (mp mockPeer) IsPersistent() bool { return true }
+func (mp mockPeer) CloseConn() error   { return nil }
+
+func (mp mockPeer) NodeInfo() p2p.NodeInfo {
+	return p2p.NodeInfo{
+		NodeID:     "",
+		ListenAddr: "",
+	}
+}
+func (mp mockPeer) Status() conn.ConnectionStatus { return conn.ConnectionStatus{} }
+func (mp mockPeer) SocketAddr() *p2p.NetAddress   { return &p2p.NetAddress{} }
+
+func (mp mockPeer) Send(byte, []byte) bool    { return true }
+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
+type mockBlockStore struct {
+	blocks map[int64]*types.Block
+}
+
+//nolint:unused
+func (ml *mockBlockStore) Height() int64 {
+	return int64(len(ml.blocks))
+}
+
+//nolint:unused
+func (ml *mockBlockStore) LoadBlock(height int64) *types.Block {
+	return ml.blocks[height]
+}
+
+//nolint:unused
+func (ml *mockBlockStore) SaveBlock(block *types.Block, part *types.PartSet, commit *types.Commit) {
+	ml.blocks[block.Height] = block
+}
+
+type mockBlockApplier struct {
+}
+
+// XXX: Add whitelist/blacklist?
+func (mba *mockBlockApplier) ApplyBlock(
+	state sm.State, blockID types.BlockID, block *types.Block,
+) (sm.State, int64, error) {
+	state.LastBlockHeight++
+	return state, 0, nil
+}
+
+type mockSwitchIo struct {
+	mtx                 sync.Mutex
+	switchedToConsensus bool
+	numStatusResponse   int
+	numBlockResponse    int
+	numNoBlockResponse  int
+	numStatusRequest    int
+}
+
+var _ iIO = (*mockSwitchIo)(nil)
+
+func (sio *mockSwitchIo) sendBlockRequest(_ p2p.Peer, _ int64) error {
+	return nil
+}
+
+func (sio *mockSwitchIo) sendStatusResponse(_, _ int64, _ p2p.Peer) error {
+	sio.mtx.Lock()
+	defer sio.mtx.Unlock()
+	sio.numStatusResponse++
+	return nil
+}
+
+func (sio *mockSwitchIo) sendBlockToPeer(_ *types.Block, _ p2p.Peer) error {
+	sio.mtx.Lock()
+	defer sio.mtx.Unlock()
+	sio.numBlockResponse++
+	return nil
+}
+
+func (sio *mockSwitchIo) sendBlockNotFound(_ int64, _ p2p.Peer) error {
+	sio.mtx.Lock()
+	defer sio.mtx.Unlock()
+	sio.numNoBlockResponse++
+	return nil
+}
+
+func (sio *mockSwitchIo) trySwitchToConsensus(_ sm.State, _ bool) bool {
+	sio.mtx.Lock()
+	defer sio.mtx.Unlock()
+	sio.switchedToConsensus = true
+	return true
+}
+
+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
+	privVals    []types.PrivValidator
+	startHeight int64
+	mockA       bool
+}
+
+func newTestReactor(p testReactorParams) *BlockchainReactor {
+	store, state, _ := newReactorStore(p.genDoc, p.privVals, p.startHeight)
+	reporter := behavior.NewMockReporter()
+
+	var appl blockApplier
+
+	if p.mockA {
+		appl = &mockBlockApplier{}
+	} else {
+		app := &testApp{}
+		cc := proxy.NewLocalClientCreator(app)
+		proxyApp := proxy.NewAppConns(cc)
+		err := proxyApp.Start()
+		if err != nil {
+			panic(fmt.Errorf("error start app: %w", err))
+		}
+		db := dbm.NewMemDB()
+		stateStore := sm.NewStore(db)
+		appl = sm.NewBlockExecutor(stateStore, p.logger, proxyApp.Consensus(), mock.Mempool{}, sm.EmptyEvidencePool{})
+		if err = stateStore.Save(state); err != nil {
+			panic(err)
+		}
+	}
+
+	r := newReactor(state, store, reporter, appl, true)
+	logger := log.TestingLogger()
+	r.SetLogger(logger.With("module", "blockchain"))
+
+	return r
+}
+
+// This test is left here and not deleted to retain the termination cases for
+// future improvement in [#4482](https://github.com/tendermint/tendermint/issues/4482).
+// func TestReactorTerminationScenarios(t *testing.T) {
+
+// 	config := cfg.ResetTestRoot("blockchain_reactor_v2_test")
+// 	defer os.RemoveAll(config.RootDir)
+// 	genDoc, privVals := randGenesisDoc(config.ChainID(), 1, false, 30)
+// 	refStore, _, _ := newReactorStore(genDoc, privVals, 20)
+
+// 	params := testReactorParams{
+// 		logger:      log.TestingLogger(),
+// 		genDoc:      genDoc,
+// 		privVals:    privVals,
+// 		startHeight: 10,
+// 		bufferSize:  100,
+// 		mockA:       true,
+// 	}
+
+// 	type testEvent struct {
+// 		evType string
+// 		peer   string
+// 		height int64
+// 	}
+
+// 	tests := []struct {
+// 		name   string
+// 		params testReactorParams
+// 		msgs   []testEvent
+// 	}{
+// 		{
+// 			name:   "simple termination on max peer height - one peer",
+// 			params: params,
+// 			msgs: []testEvent{
+// 				{evType: "AddPeer", peer: "P1"},
+// 				{evType: "ReceiveS", peer: "P1", height: 13},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P1", height: 11},
+// 				{evType: "BlockReq"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P1", height: 12},
+// 				{evType: "Process"},
+// 				{evType: "ReceiveB", peer: "P1", height: 13},
+// 				{evType: "Process"},
+// 			},
+// 		},
+// 		{
+// 			name:   "simple termination on max peer height - two peers",
+// 			params: params,
+// 			msgs: []testEvent{
+// 				{evType: "AddPeer", peer: "P1"},
+// 				{evType: "AddPeer", peer: "P2"},
+// 				{evType: "ReceiveS", peer: "P1", height: 13},
+// 				{evType: "ReceiveS", peer: "P2", height: 15},
+// 				{evType: "BlockReq"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P1", height: 11},
+// 				{evType: "ReceiveB", peer: "P2", height: 12},
+// 				{evType: "Process"},
+// 				{evType: "BlockReq"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P1", height: 13},
+// 				{evType: "Process"},
+// 				{evType: "ReceiveB", peer: "P2", height: 14},
+// 				{evType: "Process"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P2", height: 15},
+// 				{evType: "Process"},
+// 			},
+// 		},
+// 		{
+// 			name:   "termination on max peer height - two peers, noBlock error",
+// 			params: params,
+// 			msgs: []testEvent{
+// 				{evType: "AddPeer", peer: "P1"},
+// 				{evType: "AddPeer", peer: "P2"},
+// 				{evType: "ReceiveS", peer: "P1", height: 13},
+// 				{evType: "ReceiveS", peer: "P2", height: 15},
+// 				{evType: "BlockReq"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveNB", peer: "P1", height: 11},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P2", height: 12},
+// 				{evType: "ReceiveB", peer: "P2", height: 11},
+// 				{evType: "Process"},
+// 				{evType: "BlockReq"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P2", height: 13},
+// 				{evType: "Process"},
+// 				{evType: "ReceiveB", peer: "P2", height: 14},
+// 				{evType: "Process"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P2", height: 15},
+// 				{evType: "Process"},
+// 			},
+// 		},
+// 		{
+// 			name:   "termination on max peer height - two peers, remove one peer",
+// 			params: params,
+// 			msgs: []testEvent{
+// 				{evType: "AddPeer", peer: "P1"},
+// 				{evType: "AddPeer", peer: "P2"},
+// 				{evType: "ReceiveS", peer: "P1", height: 13},
+// 				{evType: "ReceiveS", peer: "P2", height: 15},
+// 				{evType: "BlockReq"},
+// 				{evType: "BlockReq"},
+// 				{evType: "RemovePeer", peer: "P1"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P2", height: 12},
+// 				{evType: "ReceiveB", peer: "P2", height: 11},
+// 				{evType: "Process"},
+// 				{evType: "BlockReq"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P2", height: 13},
+// 				{evType: "Process"},
+// 				{evType: "ReceiveB", peer: "P2", height: 14},
+// 				{evType: "Process"},
+// 				{evType: "BlockReq"},
+// 				{evType: "ReceiveB", peer: "P2", height: 15},
+// 				{evType: "Process"},
+// 			},
+// 		},
+// 	}
+
+// 	for _, tt := range tests {
+// 		tt := tt
+// 		t.Run(tt.name, func(t *testing.T) {
+// 			reactor := newTestReactor(params)
+// 			reactor.Start()
+// 			reactor.reporter = behavior.NewMockReporter()
+// 			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
+// 			reactor.io = mockSwitch
+// 			// time for go routines to start
+// 			time.Sleep(time.Millisecond)
+
+// 			for _, step := range tt.msgs {
+// 				switch step.evType {
+// 				case "AddPeer":
+// 					reactor.scheduler.send(bcAddNewPeer{peerID: p2p.ID(step.peer)})
+// 				case "RemovePeer":
+// 					reactor.scheduler.send(bcRemovePeer{peerID: p2p.ID(step.peer)})
+// 				case "ReceiveS":
+// 					reactor.scheduler.send(bcStatusResponse{
+// 						peerID: p2p.ID(step.peer),
+// 						height: step.height,
+// 						time:   time.Now(),
+// 					})
+// 				case "ReceiveB":
+// 					reactor.scheduler.send(bcBlockResponse{
+// 						peerID: p2p.ID(step.peer),
+// 						block:  refStore.LoadBlock(step.height),
+// 						size:   10,
+// 						time:   time.Now(),
+// 					})
+// 				case "ReceiveNB":
+// 					reactor.scheduler.send(bcNoBlockResponse{
+// 						peerID: p2p.ID(step.peer),
+// 						height: step.height,
+// 						time:   time.Now(),
+// 					})
+// 				case "BlockReq":
+// 					reactor.scheduler.send(rTrySchedule{time: time.Now()})
+// 				case "Process":
+// 					reactor.processor.send(rProcessBlock{})
+// 				}
+// 				// give time for messages to propagate between routines
+// 				time.Sleep(time.Millisecond)
+// 			}
+
+// 			// time for processor to finish and reactor to switch to consensus
+// 			time.Sleep(20 * time.Millisecond)
+// 			assert.True(t, mockSwitch.hasSwitchedToConsensus())
+// 			reactor.Stop()
+// 		})
+// 	}
+// }
+
+func TestReactorHelperMode(t *testing.T) {
+	var (
+		channelID = byte(0x40)
+	)
+
+	config := cfg.ResetTestRoot("blockchain_reactor_v2_test")
+	defer os.RemoveAll(config.RootDir)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
+
+	params := testReactorParams{
+		logger:      log.TestingLogger(),
+		genDoc:      genDoc,
+		privVals:    privVals,
+		startHeight: 20,
+		mockA:       true,
+	}
+
+	type testEvent struct {
+		peer  string
+		event interface{}
+	}
+
+	tests := []struct {
+		name   string
+		params testReactorParams
+		msgs   []testEvent
+	}{
+		{
+			name:   "status request",
+			params: params,
+			msgs: []testEvent{
+				{"P1", bcproto.StatusRequest{}},
+				{"P1", bcproto.BlockRequest{Height: 13}},
+				{"P1", bcproto.BlockRequest{Height: 20}},
+				{"P1", bcproto.BlockRequest{Height: 22}},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			reactor := newTestReactor(params)
+			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
+			reactor.io = mockSwitch
+			err := reactor.Start()
+			require.NoError(t, err)
+
+			for i := 0; i < len(tt.msgs); i++ {
+				step := tt.msgs[i]
+				switch ev := step.event.(type) {
+				case bcproto.StatusRequest:
+					old := mockSwitch.numStatusResponse
+
+					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
+
+						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
+
+						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)
+					}
+				}
+			}
+			err = reactor.Stop()
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestReactorSetSwitchNil(t *testing.T) {
+	config := cfg.ResetTestRoot("blockchain_reactor_v2_test")
+	defer os.RemoveAll(config.RootDir)
+	genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30)
+
+	reactor := newTestReactor(testReactorParams{
+		logger:   log.TestingLogger(),
+		genDoc:   genDoc,
+		privVals: privVals,
+	})
+	reactor.SetSwitch(nil)
+
+	assert.Nil(t, reactor.Switch)
+	assert.Nil(t, reactor.io)
+}
+
+//----------------------------------------------
+// utility funcs
+
+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
+}
+
+type testApp struct {
+	abci.BaseApplication
+}
+
+// Why are we importing the entire blockExecutor dependency graph here
+// when we have the facilities to
+func newReactorStore(
+	genDoc *types.GenesisDoc,
+	privVals []types.PrivValidator,
+	maxBlockHeight int64) (*store.BlockStore, sm.State, *sm.BlockExecutor) {
+	if len(privVals) != 1 {
+		panic("only support one validator")
+	}
+	app := &testApp{}
+	cc := proxy.NewLocalClientCreator(app)
+	proxyApp := proxy.NewAppConns(cc)
+	err := proxyApp.Start()
+	if err != nil {
+		panic(fmt.Errorf("error start app: %w", err))
+	}
+
+	stateDB := dbm.NewMemDB()
+	blockStore := store.NewBlockStore(dbm.NewMemDB())
+	stateStore := sm.NewStore(stateDB)
+	state, err := stateStore.LoadFromDBOrGenesisDoc(genDoc)
+	if err != nil {
+		panic(fmt.Errorf("error constructing state from genesis file: %w", err))
+	}
+
+	db := dbm.NewMemDB()
+	stateStore = sm.NewStore(db)
+	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
+		mock.Mempool{}, sm.EmptyEvidencePool{})
+	if err = stateStore.Save(state); err != nil {
+		panic(err)
+	}
+
+	// add blocks in
+	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(
+				privVals[0],
+				lastBlock.Header.ChainID, 0,
+				lastBlock.Header.Height, 0, 2,
+				lastBlockMeta.BlockID,
+				time.Now(),
+			)
+			if err != nil {
+				panic(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)
+		if err != nil {
+			panic(fmt.Errorf("error apply block: %w", err))
+		}
+
+		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
+	}
+	return blockStore, state, blockExec
+}

blockchain/v2/routine.go

@@ -0,0 +1,166 @@
+package v2
+
+import (
+	"fmt"
+	"strings"
+	"sync/atomic"
+
+	"github.com/Workiva/go-datastructures/queue"
+
+	"github.com/tendermint/tendermint/libs/log"
+)
+
+type handleFunc = func(event Event) (Event, error)
+
+const historySize = 25
+
+// Routine is a structure that models a finite state machine as serialized
+// stream of events processed by a handle function. This Routine structure
+// handles the concurrency and messaging guarantees. Events are sent via
+// `send` are handled by the `handle` function to produce an iterator
+// `next()`. Calling `stop()` on a routine will conclude processing of all
+// sent events and produce `final()` event representing the terminal state.
+type Routine struct {
+	name    string
+	handle  handleFunc
+	queue   *queue.PriorityQueue
+	history []Event
+	out     chan Event
+	fin     chan error
+	rdy     chan struct{}
+	running *uint32
+	logger  log.Logger
+	metrics *Metrics
+}
+
+func newRoutine(name string, handleFunc handleFunc, bufferSize int) *Routine {
+	return &Routine{
+		name:    name,
+		handle:  handleFunc,
+		queue:   queue.NewPriorityQueue(bufferSize, true),
+		history: make([]Event, 0, historySize),
+		out:     make(chan Event, bufferSize),
+		rdy:     make(chan struct{}, 1),
+		fin:     make(chan error, 1),
+		running: new(uint32),
+		logger:  log.NewNopLogger(),
+		metrics: NopMetrics(),
+	}
+}
+
+func (rt *Routine) setLogger(logger log.Logger) {
+	rt.logger = logger
+}
+
+// nolint:unused
+func (rt *Routine) setMetrics(metrics *Metrics) {
+	rt.metrics = metrics
+}
+
+func (rt *Routine) start() {
+	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))
+	}
+	close(rt.rdy)
+	defer func() {
+		if r := recover(); r != nil {
+			var (
+				b strings.Builder
+				j int
+			)
+			for i := len(rt.history) - 1; i >= 0; i-- {
+				fmt.Fprintf(&b, "%d: %+v\n", j, rt.history[i])
+				j++
+			}
+			panic(fmt.Sprintf("%v\nlast events:\n%v", r, b.String()))
+		}
+		stopped := atomic.CompareAndSwapUint32(rt.running, uint32(1), uint32(0))
+		if !stopped {
+			panic(fmt.Sprintf("%s is failed to stop", rt.name))
+		}
+	}()
+
+	for {
+		events, err := rt.queue.Get(1)
+		if err == queue.ErrDisposed {
+			rt.terminate(nil)
+			return
+		} else if err != nil {
+			rt.terminate(err)
+			return
+		}
+		oEvent, err := rt.handle(events[0].(Event))
+		rt.metrics.EventsHandled.With("routine", rt.name).Add(1)
+		if err != nil {
+			rt.terminate(err)
+			return
+		}
+		rt.metrics.EventsOut.With("routine", rt.name).Add(1)
+		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.
+		switch events[0].(type) {
+		case rTrySchedule:
+		case rProcessBlock:
+		default:
+			rt.history = append(rt.history, events[0].(Event))
+			if len(rt.history) > historySize {
+				rt.history = rt.history[1:]
+			}
+		}
+
+		rt.out <- oEvent
+	}
+}
+
+// XXX: look into returning OpError in the net package
+func (rt *Routine) send(event Event) bool {
+	rt.logger.Debug(fmt.Sprintf("%s: received %T %+v", rt.name, event, event))
+	if !rt.isRunning() {
+		return false
+	}
+	err := rt.queue.Put(event)
+	if err != nil {
+		rt.metrics.EventsShed.With("routine", rt.name).Add(1)
+		rt.logger.Error(fmt.Sprintf("%s: send failed, queue was full/stopped", rt.name))
+		return false
+	}
+
+	rt.metrics.EventsSent.With("routine", rt.name).Add(1)
+	return true
+}
+
+func (rt *Routine) isRunning() bool {
+	return atomic.LoadUint32(rt.running) == 1
+}
+
+func (rt *Routine) next() chan Event {
+	return rt.out
+}
+
+func (rt *Routine) ready() chan struct{} {
+	return rt.rdy
+}
+
+func (rt *Routine) stop() {
+	if !rt.isRunning() { // XXX: this should check rt.queue.Disposed()
+		return
+	}
+
+	rt.logger.Info(fmt.Sprintf("%s: stop", rt.name))
+	rt.queue.Dispose() // this should block until all queue items are free?
+}
+
+func (rt *Routine) final() chan error {
+	return rt.fin
+}
+
+// XXX: Maybe get rid of this
+func (rt *Routine) terminate(reason error) {
+	// We don't close the rt.out channel here, to avoid spinning on the closed channel
+	// in the event loop.
+	rt.fin <- reason
+}

blockchain/v2/routine_test.go

@@ -0,0 +1,163 @@
+package v2
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type eventA struct {
+	priorityNormal
+}
+
+var errDone = fmt.Errorf("done")
+
+func simpleHandler(event Event) (Event, error) {
+	if _, ok := event.(eventA); ok {
+		return noOp, errDone
+	}
+	return noOp, nil
+}
+
+func TestRoutineFinal(t *testing.T) {
+	var (
+		bufferSize = 10
+		routine    = newRoutine("simpleRoutine", simpleHandler, bufferSize)
+	)
+
+	assert.False(t, routine.isRunning(),
+		"expected an initialized routine to not be running")
+	go routine.start()
+	<-routine.ready()
+	assert.True(t, routine.isRunning(),
+		"expected an started routine")
+
+	assert.True(t, routine.send(eventA{}),
+		"expected sending to a ready routine to succeed")
+
+	assert.Equal(t, errDone, <-routine.final(),
+		"expected the final event to be done")
+
+	assert.False(t, routine.isRunning(),
+		"expected an completed routine to no longer be running")
+}
+
+func TestRoutineStop(t *testing.T) {
+	var (
+		bufferSize = 10
+		routine    = newRoutine("simpleRoutine", simpleHandler, bufferSize)
+	)
+
+	assert.False(t, routine.send(eventA{}),
+		"expected sending to an unstarted routine to fail")
+
+	go routine.start()
+	<-routine.ready()
+
+	assert.True(t, routine.send(eventA{}),
+		"expected sending to a running routine to succeed")
+
+	routine.stop()
+
+	assert.False(t, routine.send(eventA{}),
+		"expected sending to a stopped routine to fail")
+}
+
+type finalCount struct {
+	count int
+}
+
+func (f finalCount) Error() string {
+	return "end"
+}
+
+func genStatefulHandler(maxCount int) handleFunc {
+	counter := 0
+	return func(event Event) (Event, error) {
+		if _, ok := event.(eventA); ok {
+			counter++
+			if counter >= maxCount {
+				return noOp, finalCount{counter}
+			}
+
+			return eventA{}, nil
+		}
+		return noOp, nil
+	}
+}
+
+func feedback(r *Routine) {
+	for event := range r.next() {
+		r.send(event)
+	}
+}
+
+func TestStatefulRoutine(t *testing.T) {
+	var (
+		count      = 10
+		handler    = genStatefulHandler(count)
+		bufferSize = 20
+		routine    = newRoutine("statefulRoutine", handler, bufferSize)
+	)
+
+	go routine.start()
+	go feedback(routine)
+	<-routine.ready()
+
+	assert.True(t, routine.send(eventA{}),
+		"expected sending to a started routine to succeed")
+
+	final := <-routine.final()
+	if fnl, ok := final.(finalCount); ok {
+		assert.Equal(t, count, fnl.count,
+			"expected the routine to count to 10")
+	} else {
+		t.Fail()
+	}
+}
+
+type lowPriorityEvent struct {
+	priorityLow
+}
+
+type highPriorityEvent struct {
+	priorityHigh
+}
+
+func handleWithPriority(event Event) (Event, error) {
+	switch event.(type) {
+	case lowPriorityEvent:
+		return noOp, nil
+	case highPriorityEvent:
+		return noOp, errDone
+	}
+	return noOp, nil
+}
+
+func TestPriority(t *testing.T) {
+	var (
+		bufferSize = 20
+		routine    = newRoutine("priorityRoutine", handleWithPriority, bufferSize)
+	)
+
+	go routine.start()
+	<-routine.ready()
+	go func() {
+		for {
+			routine.send(lowPriorityEvent{})
+			time.Sleep(1 * time.Millisecond)
+		}
+	}()
+	time.Sleep(10 * time.Millisecond)
+
+	assert.True(t, routine.isRunning(),
+		"expected an started routine")
+	assert.True(t, routine.send(highPriorityEvent{}),
+		"expected send to succeed even when saturated")
+
+	assert.Equal(t, errDone, <-routine.final())
+	assert.False(t, routine.isRunning(),
+		"expected an started routine")
+}

blockchain/v2/scheduler.go

@@ -0,0 +1,712 @@
+package v2
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"math"
+	"sort"
+	"time"
+
+	"github.com/tendermint/tendermint/p2p"
+	"github.com/tendermint/tendermint/types"
+)
+
+// Events generated by the scheduler:
+// all blocks have been processed
+type scFinishedEv struct {
+	priorityNormal
+	reason string
+}
+
+func (e scFinishedEv) String() string {
+	return fmt.Sprintf("scFinishedEv{%v}", e.reason)
+}
+
+// send a blockRequest message
+type scBlockRequest struct {
+	priorityNormal
+	peerID p2p.NodeID
+	height int64
+}
+
+func (e scBlockRequest) String() string {
+	return fmt.Sprintf("scBlockRequest{%d from %v}", e.height, e.peerID)
+}
+
+// a block has been received and validated by the scheduler
+type scBlockReceived struct {
+	priorityNormal
+	peerID p2p.NodeID
+	block  *types.Block
+}
+
+func (e scBlockReceived) String() string {
+	return fmt.Sprintf("scBlockReceived{%d#%X from %v}", e.block.Height, e.block.Hash(), e.peerID)
+}
+
+// scheduler detected a peer error
+type scPeerError struct {
+	priorityHigh
+	peerID p2p.NodeID
+	reason error
+}
+
+func (e scPeerError) String() string {
+	return fmt.Sprintf("scPeerError{%v errored with %v}", e.peerID, e.reason)
+}
+
+// scheduler removed a set of peers (timed out or slow peer)
+type scPeersPruned struct {
+	priorityHigh
+	peers []p2p.NodeID
+}
+
+func (e scPeersPruned) String() string {
+	return fmt.Sprintf("scPeersPruned{%v}", e.peers)
+}
+
+// XXX: make this fatal?
+// scheduler encountered a fatal error
+type scSchedulerFail struct {
+	priorityHigh
+	reason error
+}
+
+func (e scSchedulerFail) String() string {
+	return fmt.Sprintf("scSchedulerFail{%v}", e.reason)
+}
+
+type blockState int
+
+const (
+	blockStateUnknown   blockState = iota + 1 // no known peer has this block
+	blockStateNew                             // indicates that a peer has reported having this block
+	blockStatePending                         // indicates that this block has been requested from a peer
+	blockStateReceived                        // indicates that this block has been received by a peer
+	blockStateProcessed                       // indicates that this block has been applied
+)
+
+func (e blockState) String() string {
+	switch e {
+	case blockStateUnknown:
+		return "Unknown"
+	case blockStateNew:
+		return "New"
+	case blockStatePending:
+		return "Pending"
+	case blockStateReceived:
+		return "Received"
+	case blockStateProcessed:
+		return "Processed"
+	default:
+		return fmt.Sprintf("invalid blockState: %d", e)
+	}
+}
+
+type peerState int
+
+const (
+	peerStateNew = iota + 1
+	peerStateReady
+	peerStateRemoved
+)
+
+func (e peerState) String() string {
+	switch e {
+	case peerStateNew:
+		return "New"
+	case peerStateReady:
+		return "Ready"
+	case peerStateRemoved:
+		return "Removed"
+	default:
+		panic(fmt.Sprintf("unknown peerState: %d", e))
+	}
+}
+
+type scPeer struct {
+	peerID p2p.NodeID
+
+	// initialized as New when peer is added, updated to Ready when statusUpdate is received,
+	// updated to Removed when peer is removed
+	state peerState
+
+	base        int64 // updated when statusResponse is received
+	height      int64 // updated when statusResponse is received
+	lastTouched time.Time
+	lastRate    int64 // last receive rate in bytes
+}
+
+func (p scPeer) String() string {
+	return fmt.Sprintf("{state %v, base %d, height %d, lastTouched %v, lastRate %d, id %v}",
+		p.state, p.base, p.height, p.lastTouched, p.lastRate, p.peerID)
+}
+
+func newScPeer(peerID p2p.NodeID) *scPeer {
+	return &scPeer{
+		peerID:      peerID,
+		state:       peerStateNew,
+		base:        -1,
+		height:      -1,
+		lastTouched: time.Time{},
+	}
+}
+
+// The scheduler keep track of the state of each block and each peer. The
+// scheduler will attempt to schedule new block requests with `trySchedule`
+// events and remove slow peers with `tryPrune` events.
+type scheduler struct {
+	initHeight int64
+
+	// next block that needs to be processed. All blocks with smaller height are
+	// in Processed state.
+	height int64
+
+	// lastAdvance tracks the last time a block execution happened.
+	// syncTimeout is the maximum time the scheduler waits to advance in the fast sync process before finishing.
+	// This covers the cases where there are no peers or all peers have a lower height.
+	lastAdvance time.Time
+	syncTimeout time.Duration
+
+	// a map of peerID to scheduler specific peer struct `scPeer` used to keep
+	// track of peer specific state
+	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
+
+	// the maximum number of blocks that should be New, Received or Pending at any point
+	// in time. This is used to enforce a limit on the blockStates map.
+	targetPending int
+	// a list of blocks to be scheduled (New), Pending or Received. Its length should be
+	// smaller than targetPending.
+	blockStates map[int64]blockState
+
+	// a map of heights to the peer we are waiting a response from
+	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.NodeID
+}
+
+func (sc scheduler) String() string {
+	return fmt.Sprintf("ih: %d, bst: %v, peers: %v, pblks: %v, ptm %v, rblks: %v",
+		sc.initHeight, sc.blockStates, sc.peers, sc.pendingBlocks, sc.pendingTime, sc.receivedBlocks)
+}
+
+func newScheduler(initHeight int64, startTime time.Time) *scheduler {
+	sc := scheduler{
+		initHeight:     initHeight,
+		lastAdvance:    startTime,
+		syncTimeout:    60 * time.Second,
+		height:         initHeight,
+		blockStates:    make(map[int64]blockState),
+		peers:          make(map[p2p.NodeID]*scPeer),
+		pendingBlocks:  make(map[int64]p2p.NodeID),
+		pendingTime:    make(map[int64]time.Time),
+		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
+	}
+
+	return &sc
+}
+
+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.NodeID, time time.Time) error {
+	peer, ok := sc.peers[peerID]
+	if !ok {
+		return fmt.Errorf("couldn't find peer %s", peerID)
+	}
+
+	if peer.state != peerStateReady {
+		return fmt.Errorf("tried to touch peer in state %s, must be Ready", peer.state)
+	}
+
+	peer.lastTouched = time
+
+	return nil
+}
+
+func (sc *scheduler) removePeer(peerID p2p.NodeID) {
+	peer, ok := sc.peers[peerID]
+	if !ok {
+		return
+	}
+	if peer.state == peerStateRemoved {
+		return
+	}
+
+	for height, pendingPeerID := range sc.pendingBlocks {
+		if pendingPeerID == peerID {
+			sc.setStateAtHeight(height, blockStateNew)
+			delete(sc.pendingTime, height)
+			delete(sc.pendingBlocks, height)
+		}
+	}
+
+	for height, rcvPeerID := range sc.receivedBlocks {
+		if rcvPeerID == peerID {
+			sc.setStateAtHeight(height, blockStateNew)
+			delete(sc.receivedBlocks, height)
+		}
+	}
+
+	// remove the blocks from blockStates if the peer removal causes the max peer height to be lower.
+	peer.state = peerStateRemoved
+	maxPeerHeight := int64(0)
+	for _, otherPeer := range sc.peers {
+		if otherPeer.state != peerStateReady {
+			continue
+		}
+		if otherPeer.peerID != peer.peerID && otherPeer.height > maxPeerHeight {
+			maxPeerHeight = otherPeer.height
+		}
+	}
+	for h := range sc.blockStates {
+		if h > maxPeerHeight {
+			delete(sc.blockStates, h)
+		}
+	}
+}
+
+// check if the blockPool is running low and add new blocks in New state to be requested.
+// This function is called when there is an increase in the maximum peer height or when
+// blocks are processed.
+func (sc *scheduler) addNewBlocks() {
+	if len(sc.blockStates) >= sc.targetPending {
+		return
+	}
+
+	for i := sc.height; i < int64(sc.targetPending)+sc.height; i++ {
+		if i > sc.maxHeight() {
+			break
+		}
+		if sc.getStateAtHeight(i) == blockStateUnknown {
+			sc.setStateAtHeight(i, blockStateNew)
+		}
+	}
+}
+
+func (sc *scheduler) setPeerRange(peerID p2p.NodeID, base int64, height int64) error {
+	peer := sc.ensurePeer(peerID)
+
+	if peer.state == peerStateRemoved {
+		return nil // noop
+	}
+
+	if height < peer.height {
+		sc.removePeer(peerID)
+		return fmt.Errorf("cannot move peer height lower. from %d to %d", peer.height, height)
+	}
+
+	if base > height {
+		sc.removePeer(peerID)
+		return fmt.Errorf("cannot set peer base higher than its height")
+	}
+
+	peer.base = base
+	peer.height = height
+	peer.state = peerStateReady
+
+	sc.addNewBlocks()
+	return nil
+}
+
+func (sc *scheduler) getStateAtHeight(height int64) blockState {
+	if height < sc.height {
+		return blockStateProcessed
+	} else if state, ok := sc.blockStates[height]; ok {
+		return state
+	} else {
+		return blockStateUnknown
+	}
+}
+
+func (sc *scheduler) getPeersWithHeight(height int64) []p2p.NodeID {
+	peers := make([]p2p.NodeID, 0)
+	for _, peer := range sc.peers {
+		if peer.state != peerStateReady {
+			continue
+		}
+		if peer.base <= height && peer.height >= height {
+			peers = append(peers, peer.peerID)
+		}
+	}
+	return peers
+}
+
+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
+		}
+		if now.Sub(peer.lastTouched) > peerTimout || peer.lastRate < minRecvRate {
+			prunable = append(prunable, peerID)
+		}
+	}
+	// Tests for handleTryPrunePeer() may fail without sort due to range non-determinism
+	sort.Sort(PeerByID(prunable))
+	return prunable
+}
+
+func (sc *scheduler) setStateAtHeight(height int64, state blockState) {
+	sc.blockStates[height] = state
+}
+
+// CONTRACT: peer exists and in Ready state.
+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 {
+		return fmt.Errorf("received block %d from peer %s without being requested", height, peerID)
+	}
+
+	pendingTime, ok := sc.pendingTime[height]
+	if !ok || now.Sub(pendingTime) <= 0 {
+		return fmt.Errorf("clock error: block %d received at %s but requested at %s",
+			height, pendingTime, now)
+	}
+
+	peer.lastRate = size / now.Sub(pendingTime).Nanoseconds()
+
+	sc.setStateAtHeight(height, blockStateReceived)
+	delete(sc.pendingBlocks, height)
+	delete(sc.pendingTime, height)
+
+	sc.receivedBlocks[height] = peerID
+
+	return nil
+}
+
+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)
+	}
+
+	peer, ok := sc.peers[peerID]
+	if !ok {
+		return fmt.Errorf("cannot find peer %s", peerID)
+	}
+
+	if peer.state != peerStateReady {
+		return fmt.Errorf("cannot schedule %d from %s in %s", height, peerID, peer.state)
+	}
+
+	if height > peer.height {
+		return fmt.Errorf("cannot request height %d from peer %s that is at height %d",
+			height, peerID, peer.height)
+	}
+
+	if height < peer.base {
+		return fmt.Errorf("cannot request height %d for peer %s with base %d",
+			height, peerID, peer.base)
+	}
+
+	sc.setStateAtHeight(height, blockStatePending)
+	sc.pendingBlocks[height] = peerID
+	sc.pendingTime[height] = time
+
+	return nil
+}
+
+func (sc *scheduler) markProcessed(height int64) error {
+	// It is possible that a peer error or timeout is handled after the processor
+	// has processed the block but before the scheduler received this event, so
+	// when pcBlockProcessed event is received, the block had been requested
+	// again => don't check the block state.
+	sc.lastAdvance = time.Now()
+	sc.height = height + 1
+	delete(sc.pendingBlocks, height)
+	delete(sc.pendingTime, height)
+	delete(sc.receivedBlocks, height)
+	delete(sc.blockStates, height)
+	sc.addNewBlocks()
+	return nil
+}
+
+func (sc *scheduler) allBlocksProcessed() bool {
+	if len(sc.peers) == 0 {
+		return false
+	}
+	return sc.height >= sc.maxHeight()
+}
+
+// returns max peer height or the last processed block, i.e. sc.height
+func (sc *scheduler) maxHeight() int64 {
+	max := sc.height - 1
+	for _, peer := range sc.peers {
+		if peer.state != peerStateReady {
+			continue
+		}
+		if max < peer.height {
+			max = peer.height
+		}
+	}
+	return max
+}
+
+// lowest block in sc.blockStates with state == blockStateNew or -1 if no new blocks
+func (sc *scheduler) nextHeightToSchedule() int64 {
+	var min int64 = math.MaxInt64
+	for height, state := range sc.blockStates {
+		if state == blockStateNew && height < min {
+			min = height
+		}
+	}
+	if min == math.MaxInt64 {
+		min = -1
+	}
+	return min
+}
+
+func (sc *scheduler) pendingFrom(peerID p2p.NodeID) []int64 {
+	var heights []int64
+	for height, pendingPeerID := range sc.pendingBlocks {
+		if pendingPeerID == peerID {
+			heights = append(heights, height)
+		}
+	}
+	return heights
+}
+
+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)
+	}
+
+	// create a map from number of pending requests to a list
+	// of peers having that number of pending requests.
+	pendingFrom := make(map[int][]p2p.NodeID)
+	for _, peerID := range peers {
+		numPending := len(sc.pendingFrom(peerID))
+		pendingFrom[numPending] = append(pendingFrom[numPending], peerID)
+	}
+
+	// find the set of peers with minimum number of pending requests.
+	var minPending int64 = math.MaxInt64
+	for mp := range pendingFrom {
+		if int64(mp) < minPending {
+			minPending = int64(mp)
+		}
+	}
+
+	sort.Sort(PeerByID(pendingFrom[int(minPending)]))
+	return pendingFrom[int(minPending)][0], nil
+}
+
+// PeerByID is a list of peers sorted by peerID.
+type PeerByID []p2p.NodeID
+
+func (peers PeerByID) Len() int {
+	return len(peers)
+}
+func (peers PeerByID) Less(i, j int) bool {
+	return bytes.Compare([]byte(peers[i]), []byte(peers[j])) == -1
+}
+
+func (peers PeerByID) Swap(i, j int) {
+	peers[i], peers[j] = peers[j], peers[i]
+}
+
+// Handlers
+
+// This handler gets the block, performs some validation and then passes it on to the processor.
+func (sc *scheduler) handleBlockResponse(event bcBlockResponse) (Event, error) {
+	err := sc.touchPeer(event.peerID, event.time)
+	if err != nil {
+		// peer does not exist OR not ready
+		return noOp, nil
+	}
+
+	err = sc.markReceived(event.peerID, event.block.Height, event.size, event.time)
+	if err != nil {
+		sc.removePeer(event.peerID)
+		return scPeerError{peerID: event.peerID, reason: err}, nil
+	}
+
+	return scBlockReceived{peerID: event.peerID, block: event.block}, nil
+}
+
+func (sc *scheduler) handleNoBlockResponse(event bcNoBlockResponse) (Event, error) {
+	// No such peer or peer was removed.
+	peer, ok := sc.peers[event.peerID]
+	if !ok || peer.state == peerStateRemoved {
+		return noOp, nil
+	}
+
+	// The peer may have been just removed due to errors, low speed or timeouts.
+	sc.removePeer(event.peerID)
+
+	return scPeerError{peerID: event.peerID,
+		reason: fmt.Errorf("peer %v with base %d height %d claims no block for %d",
+			event.peerID, peer.base, peer.height, event.height)}, nil
+}
+
+func (sc *scheduler) handleBlockProcessed(event pcBlockProcessed) (Event, error) {
+	if event.height != sc.height {
+		panic(fmt.Sprintf("processed height %d, but expected height %d", event.height, sc.height))
+	}
+
+	err := sc.markProcessed(event.height)
+	if err != nil {
+		return scSchedulerFail{reason: err}, nil
+	}
+
+	if sc.allBlocksProcessed() {
+		return scFinishedEv{reason: "processed all blocks"}, nil
+	}
+
+	return noOp, nil
+}
+
+// Handles an error from the processor. The processor had already cleaned the blocks from
+// the peers included in this event. Just attempt to remove the peers.
+func (sc *scheduler) handleBlockProcessError(event pcBlockVerificationFailure) (Event, error) {
+	// The peers may have been just removed due to errors, low speed or timeouts.
+	sc.removePeer(event.firstPeerID)
+	if event.firstPeerID != event.secondPeerID {
+		sc.removePeer(event.secondPeerID)
+	}
+
+	if sc.allBlocksProcessed() {
+		return scFinishedEv{reason: "error on last block"}, nil
+	}
+
+	return noOp, nil
+}
+
+func (sc *scheduler) handleAddNewPeer(event bcAddNewPeer) (Event, error) {
+	sc.ensurePeer(event.peerID)
+	return noOp, nil
+}
+
+func (sc *scheduler) handleRemovePeer(event bcRemovePeer) (Event, error) {
+	sc.removePeer(event.peerID)
+
+	if sc.allBlocksProcessed() {
+		return scFinishedEv{reason: "removed peer"}, nil
+	}
+
+	// Return scPeerError so the peer (and all associated blocks) is removed from
+	// the processor.
+	return scPeerError{peerID: event.peerID, reason: errors.New("peer was stopped")}, nil
+}
+
+func (sc *scheduler) handleTryPrunePeer(event rTryPrunePeer) (Event, error) {
+	// Check behavior of peer responsible to deliver block at sc.height.
+	timeHeightAsked, ok := sc.pendingTime[sc.height]
+	if ok && time.Since(timeHeightAsked) > sc.peerTimeout {
+		// A request was sent to a peer for block at sc.height but a response was not received
+		// from that peer within sc.peerTimeout. Remove the peer. This is to ensure that a peer
+		// will be timed out even if it sends blocks at higher heights but prevents progress by
+		// not sending the block at current height.
+		sc.removePeer(sc.pendingBlocks[sc.height])
+	}
+
+	prunablePeers := sc.prunablePeers(sc.peerTimeout, sc.minRecvRate, event.time)
+	if len(prunablePeers) == 0 {
+		return noOp, nil
+	}
+	for _, peerID := range prunablePeers {
+		sc.removePeer(peerID)
+	}
+
+	// If all blocks are processed we should finish.
+	if sc.allBlocksProcessed() {
+		return scFinishedEv{reason: "after try prune"}, nil
+	}
+
+	return scPeersPruned{peers: prunablePeers}, nil
+}
+
+func (sc *scheduler) handleResetState(event bcResetState) (Event, error) {
+	initHeight := event.state.LastBlockHeight + 1
+	if initHeight == 1 {
+		initHeight = event.state.InitialHeight
+	}
+	sc.initHeight = initHeight
+	sc.height = initHeight
+	sc.lastAdvance = time.Now()
+	sc.addNewBlocks()
+	return noOp, nil
+}
+
+func (sc *scheduler) handleTrySchedule(event rTrySchedule) (Event, error) {
+	if time.Since(sc.lastAdvance) > sc.syncTimeout {
+		return scFinishedEv{reason: "timeout, no advance"}, nil
+	}
+
+	nextHeight := sc.nextHeightToSchedule()
+	if nextHeight == -1 {
+		return noOp, nil
+	}
+
+	bestPeerID, err := sc.selectPeer(nextHeight)
+	if err != nil {
+		return scSchedulerFail{reason: err}, nil
+	}
+	if err := sc.markPending(bestPeerID, nextHeight, event.time); err != nil {
+		return scSchedulerFail{reason: err}, nil // XXX: peerError might be more appropriate
+	}
+	return scBlockRequest{peerID: bestPeerID, height: nextHeight}, nil
+
+}
+
+func (sc *scheduler) handleStatusResponse(event bcStatusResponse) (Event, error) {
+	err := sc.setPeerRange(event.peerID, event.base, event.height)
+	if err != nil {
+		return scPeerError{peerID: event.peerID, reason: err}, nil
+	}
+	return noOp, nil
+}
+
+func (sc *scheduler) handle(event Event) (Event, error) {
+	switch event := event.(type) {
+	case bcResetState:
+		nextEvent, err := sc.handleResetState(event)
+		return nextEvent, err
+	case bcStatusResponse:
+		nextEvent, err := sc.handleStatusResponse(event)
+		return nextEvent, err
+	case bcBlockResponse:
+		nextEvent, err := sc.handleBlockResponse(event)
+		return nextEvent, err
+	case bcNoBlockResponse:
+		nextEvent, err := sc.handleNoBlockResponse(event)
+		return nextEvent, err
+	case rTrySchedule:
+		nextEvent, err := sc.handleTrySchedule(event)
+		return nextEvent, err
+	case bcAddNewPeer:
+		nextEvent, err := sc.handleAddNewPeer(event)
+		return nextEvent, err
+	case bcRemovePeer:
+		nextEvent, err := sc.handleRemovePeer(event)
+		return nextEvent, err
+	case rTryPrunePeer:
+		nextEvent, err := sc.handleTryPrunePeer(event)
+		return nextEvent, err
+	case pcBlockProcessed:
+		nextEvent, err := sc.handleBlockProcessed(event)
+		return nextEvent, err
+	case pcBlockVerificationFailure:
+		nextEvent, err := sc.handleBlockProcessError(event)
+		return nextEvent, err
+	default:
+		return scSchedulerFail{reason: fmt.Errorf("unknown event %v", event)}, nil
+	}
+}

blockchain/v2/types.go

@@ -0,0 +1,65 @@
+package v2
+
+import (
+	"github.com/Workiva/go-datastructures/queue"
+)
+
+// Event is the type that can be added to the priority queue.
+type Event queue.Item
+
+type priority interface {
+	Compare(other queue.Item) int
+	Priority() int
+}
+
+type priorityLow struct{}
+type priorityNormal struct{}
+type priorityHigh struct{}
+
+func (p priorityLow) Priority() int {
+	return 1
+}
+
+func (p priorityNormal) Priority() int {
+	return 2
+}
+
+func (p priorityHigh) Priority() int {
+	return 3
+}
+
+func (p priorityLow) Compare(other queue.Item) int {
+	op := other.(priority)
+	if p.Priority() > op.Priority() {
+		return 1
+	} else if p.Priority() == op.Priority() {
+		return 0
+	}
+	return -1
+}
+
+func (p priorityNormal) Compare(other queue.Item) int {
+	op := other.(priority)
+	if p.Priority() > op.Priority() {
+		return 1
+	} else if p.Priority() == op.Priority() {
+		return 0
+	}
+	return -1
+}
+
+func (p priorityHigh) Compare(other queue.Item) int {
+	op := other.(priority)
+	if p.Priority() > op.Priority() {
+		return 1
+	} else if p.Priority() == op.Priority() {
+		return 0
+	}
+	return -1
+}
+
+type noOpEvent struct {
+	priorityLow
+}
+
+var noOp = noOpEvent{}

buf.gen.yaml

@@ -0,0 +1,13 @@
+# 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
+    # 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.yaml

@@ -0,0 +1,16 @@
+version: v1beta1
+
+build:
+  roots:
+    - proto
+    - third_party/proto
+lint:
+  use:
+    - BASIC
+    - FILE_LOWER_SNAKE_CASE
+    - UNARY_RPC
+  ignore:
+    - gogoproto
+breaking:
+  use:
+    - FILE

cmd/priv_val_server/main.go

@@ -6,6 +6,7 @@ import (
 	"crypto/x509"
 	"flag"
 	"fmt"
+	"io/ioutil"
 	"net"
 	"net/http"
 	"os"
@@ -45,14 +46,12 @@ func main() {
 		rootCA           = flag.String("rootcafile", "", "absolute path to root CA")
 		prometheusAddr   = flag.String("prometheus-addr", "", "address for prometheus endpoint (host:port)")
 
-		logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false).
-			With("module", "priv_val")
+		logger = log.NewTMLogger(
+			log.NewSyncWriter(os.Stdout),
+		).With("module", "priv_val")
 	)
 	flag.Parse()
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	logger.Info(
 		"Starting private validator",
 		"addr", *addr,
@@ -80,7 +79,7 @@ func main() {
 		}
 
 		certPool := x509.NewCertPool()
-		bs, err := os.ReadFile(*rootCA)
+		bs, err := ioutil.ReadFile(*rootCA)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "failed to read client ca cert: %s", err)
 			os.Exit(1)
@@ -134,7 +133,7 @@ func main() {
 	}
 
 	// Stop upon receiving SIGTERM or CTRL-C.
-	tmos.TrapSignal(ctx, logger, func() {
+	tmos.TrapSignal(logger, func() {
 		logger.Debug("SignerServer: calling Close")
 		if *prometheusAddr != "" {
 			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)

cmd/tendermint/commands/debug/debug.go

@@ -1,6 +1,8 @@
 package debug
 
 import (
+	"os"
+
 	"github.com/spf13/cobra"
 
 	"github.com/tendermint/tendermint/libs/log"
@@ -15,7 +17,7 @@ var (
 	flagProfAddr    = "pprof-laddr"
 	flagFrequency   = "frequency"
 
-	logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
+	logger = log.NewTMLogger(log.NewSyncWriter(os.Stdout))
 )
 
 // DebugCmd defines the root command containing subcommands that assist in

cmd/tendermint/commands/debug/dump.go

@@ -3,6 +3,7 @@ package debug
 import (
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"time"
@@ -10,7 +11,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
-	"github.com/tendermint/tendermint/config"
+	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/cli"
 	rpchttp "github.com/tendermint/tendermint/rpc/client/http"
 )
@@ -64,9 +65,9 @@ func dumpCmdHandler(_ *cobra.Command, args []string) error {
 	}
 
 	home := viper.GetString(cli.HomeFlag)
-	conf := config.DefaultConfig()
+	conf := cfg.DefaultConfig()
 	conf = conf.SetRoot(home)
-	config.EnsureRoot(conf.RootDir)
+	cfg.EnsureRoot(conf.RootDir)
 
 	dumpDebugData(outDir, conf, rpc)
 
@@ -78,10 +79,10 @@ func dumpCmdHandler(_ *cobra.Command, args []string) error {
 	return nil
 }
 
-func dumpDebugData(outDir string, conf *config.Config, rpc *rpchttp.HTTP) {
+func dumpDebugData(outDir string, conf *cfg.Config, rpc *rpchttp.HTTP) {
 	start := time.Now().UTC()
 
-	tmpDir, err := os.MkdirTemp(outDir, "tendermint_debug_tmp")
+	tmpDir, err := ioutil.TempDir(outDir, "tendermint_debug_tmp")
 	if err != nil {
 		logger.Error("failed to create temporary directory", "dir", tmpDir, "error", err)
 		return

cmd/tendermint/commands/debug/io.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
@@ -110,5 +111,5 @@ func writeStateJSONToFile(state interface{}, dir, filename string) error {
 		return fmt.Errorf("failed to encode state dump: %w", err)
 	}
 
-	return os.WriteFile(path.Join(dir, filename), stateJSON, os.ModePerm)
+	return ioutil.WriteFile(path.Join(dir, filename), stateJSON, os.ModePerm)
 }

cmd/tendermint/commands/debug/kill.go

@@ -3,6 +3,7 @@ package debug
 import (
 	"errors"
 	"fmt"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -13,7 +14,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 
-	"github.com/tendermint/tendermint/config"
+	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/cli"
 	rpchttp "github.com/tendermint/tendermint/rpc/client/http"
 )
@@ -33,7 +34,7 @@ $ tendermint debug kill 34255 /path/to/tm-debug.zip`,
 }
 
 func killCmdHandler(cmd *cobra.Command, args []string) error {
-	pid, err := strconv.ParseInt(args[0], 10, 64)
+	pid, err := strconv.ParseUint(args[0], 10, 64)
 	if err != nil {
 		return err
 	}
@@ -49,13 +50,13 @@ func killCmdHandler(cmd *cobra.Command, args []string) error {
 	}
 
 	home := viper.GetString(cli.HomeFlag)
-	conf := config.DefaultConfig()
+	conf := cfg.DefaultConfig()
 	conf = conf.SetRoot(home)
-	config.EnsureRoot(conf.RootDir)
+	cfg.EnsureRoot(conf.RootDir)
 
 	// Create a temporary directory which will contain all the state dumps and
 	// relevant files and directories that will be compressed into a file.
-	tmpDir, err := os.MkdirTemp(os.TempDir(), "tendermint_debug_tmp")
+	tmpDir, err := ioutil.TempDir(os.TempDir(), "tendermint_debug_tmp")
 	if err != nil {
 		return fmt.Errorf("failed to create temporary directory: %w", err)
 	}
@@ -91,7 +92,7 @@ func killCmdHandler(cmd *cobra.Command, args []string) error {
 	}
 
 	logger.Info("killing Tendermint process")
-	if err := killProc(int(pid), tmpDir); err != nil {
+	if err := killProc(pid, tmpDir); err != nil {
 		return err
 	}
 
@@ -104,7 +105,7 @@ func killCmdHandler(cmd *cobra.Command, args []string) error {
 // is tailed and piped to a file under the directory dir. An error is returned
 // if the output file cannot be created or the tail command cannot be started.
 // An error is not returned if any subsequent syscall fails.
-func killProc(pid int, dir string) error {
+func killProc(pid uint64, dir string) error {
 	// pipe STDERR output from tailing the Tendermint process to a file
 	//
 	// NOTE: This will only work on UNIX systems.
@@ -127,7 +128,7 @@ func killProc(pid int, dir string) error {
 	go func() {
 		// Killing the Tendermint process with the '-ABRT|-6' signal will result in
 		// a goroutine stacktrace.
-		p, err := os.FindProcess(pid)
+		p, err := os.FindProcess(int(pid))
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "failed to find PID to kill Tendermint process: %s", err)
 		} else if err = p.Signal(syscall.SIGABRT); err != nil {

cmd/tendermint/commands/debug/util.go

@@ -3,13 +3,13 @@ package debug
 import (
 	"context"
 	"fmt"
-	"io"
+	"io/ioutil"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
 
-	"github.com/tendermint/tendermint/config"
+	cfg "github.com/tendermint/tendermint/config"
 	rpchttp "github.com/tendermint/tendermint/rpc/client/http"
 )
 
@@ -48,7 +48,7 @@ func dumpConsensusState(rpc *rpchttp.HTTP, dir, filename string) error {
 
 // copyWAL copies the Tendermint node's WAL file. It returns an error if the
 // WAL file cannot be read or copied.
-func copyWAL(conf *config.Config, dir string) error {
+func copyWAL(conf *cfg.Config, dir string) error {
 	walPath := conf.Consensus.WalFile()
 	walFile := filepath.Base(walPath)
 
@@ -73,10 +73,10 @@ func dumpProfile(dir, addr, profile string, debug int) error {
 	}
 	defer resp.Body.Close()
 
-	body, err := io.ReadAll(resp.Body)
+	body, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
 		return fmt.Errorf("failed to read %s profile response body: %w", profile, err)
 	}
 
-	return os.WriteFile(path.Join(dir, fmt.Sprintf("%s.out", profile)), body, os.ModePerm)
+	return ioutil.WriteFile(path.Join(dir, fmt.Sprintf("%s.out", profile)), body, os.ModePerm)
 }

cmd/tendermint/commands/gen_node_key.go

@@ -6,19 +6,21 @@ import (
 	"github.com/spf13/cobra"
 
 	tmjson "github.com/tendermint/tendermint/libs/json"
-	"github.com/tendermint/tendermint/types"
+	"github.com/tendermint/tendermint/p2p"
 )
 
 // GenNodeKeyCmd allows the generation of a node key. It prints JSON-encoded
 // NodeKey to the standard output.
 var GenNodeKeyCmd = &cobra.Command{
-	Use:   "gen-node-key",
-	Short: "Generate a new node key",
-	RunE:  genNodeKey,
+	Use:     "gen-node-key",
+	Aliases: []string{"gen_node_key"},
+	Short:   "Generate a new node key",
+	RunE:    genNodeKey,
+	PreRun:  deprecateSnakeCase,
 }
 
 func genNodeKey(cmd *cobra.Command, args []string) error {
-	nodeKey := types.GenNodeKey()
+	nodeKey := p2p.GenNodeKey()
 
 	bz, err := tmjson.Marshal(nodeKey)
 	if err != nil {

cmd/tendermint/commands/gen_validator.go

@@ -13,9 +13,11 @@ import (
 // GenValidatorCmd allows the generation of a keypair for a
 // validator.
 var GenValidatorCmd = &cobra.Command{
-	Use:   "gen-validator",
-	Short: "Generate new validator keypair",
-	RunE:  genValidator,
+	Use:     "gen-validator",
+	Aliases: []string{"gen_validator"},
+	Short:   "Generate new validator keypair",
+	RunE:    genValidator,
+	PreRun:  deprecateSnakeCase,
 }
 
 func init() {

cmd/tendermint/commands/init.go

@@ -10,9 +10,10 @@ import (
 	cfg "github.com/tendermint/tendermint/config"
 	tmos "github.com/tendermint/tendermint/libs/os"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
-	tmtime "github.com/tendermint/tendermint/libs/time"
+	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/privval"
 	"github.com/tendermint/tendermint/types"
+	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
 // InitFilesCmd initializes a fresh Tendermint Core instance.
@@ -50,8 +51,8 @@ func initFilesWithConfig(config *cfg.Config) error {
 
 	if config.Mode == cfg.ModeValidator {
 		// private validator
-		privValKeyFile := config.PrivValidator.KeyFile()
-		privValStateFile := config.PrivValidator.StateFile()
+		privValKeyFile := config.PrivValidatorKeyFile()
+		privValStateFile := config.PrivValidatorStateFile()
 		if tmos.FileExists(privValKeyFile) {
 			pv, err = privval.LoadFilePV(privValKeyFile, privValStateFile)
 			if err != nil {
@@ -75,7 +76,7 @@ func initFilesWithConfig(config *cfg.Config) error {
 	if tmos.FileExists(nodeKeyFile) {
 		logger.Info("Found node key", "path", nodeKeyFile)
 	} else {
-		if _, err := types.LoadOrGenNodeKey(nodeKeyFile); err != nil {
+		if _, err := p2p.LoadOrGenNodeKey(nodeKeyFile); err != nil {
 			return err
 		}
 		logger.Info("Generated node key", "path", nodeKeyFile)
@@ -121,9 +122,7 @@ func initFilesWithConfig(config *cfg.Config) error {
 	}
 
 	// write config file
-	if err := cfg.WriteConfigFile(config.RootDir, config); err != nil {
-		return err
-	}
+	cfg.WriteConfigFile(config.RootDir, config)
 	logger.Info("Generated config", "mode", config.Mode)
 
 	return nil

cmd/tendermint/commands/inspect.go

@@ -1,54 +0,0 @@
-package commands
-
-import (
-	"os/signal"
-	"syscall"
-
-	"github.com/spf13/cobra"
-
-	"github.com/tendermint/tendermint/internal/inspect"
-)
-
-// InspectCmd is the command for starting an inspect server.
-var InspectCmd = &cobra.Command{
-	Use:   "inspect",
-	Short: "Run an inspect server for investigating Tendermint state",
-	Long: `
-	inspect runs a subset of Tendermint's RPC endpoints that are useful for debugging
-	issues with Tendermint.
-
-	When the Tendermint consensus engine detects inconsistent state, it will crash the
-	tendermint process. Tendermint will not start up while in this inconsistent state. 
-	The inspect command can be used to query the block and state store using Tendermint
-	RPC calls to debug issues of inconsistent state.
-	`,
-
-	RunE: runInspect,
-}
-
-func init() {
-	InspectCmd.Flags().
-		String("rpc.laddr",
-			config.RPC.ListenAddress, "RPC listenener address. Port required")
-	InspectCmd.Flags().
-		String("db-backend",
-			config.DBBackend, "database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb")
-	InspectCmd.Flags().
-		String("db-dir", config.DBPath, "database directory")
-}
-
-func runInspect(cmd *cobra.Command, args []string) error {
-	ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM, syscall.SIGINT)
-	defer cancel()
-
-	ins, err := inspect.NewFromConfig(logger, config)
-	if err != nil {
-		return err
-	}
-
-	logger.Info("starting inspect server")
-	if err := ins.Run(ctx); err != nil {
-		return err
-	}
-	return nil
-}

cmd/tendermint/commands/key_migrate.go

@@ -1,64 +0,0 @@
-package commands
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/spf13/cobra"
-	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/scripts/keymigrate"
-)
-
-func MakeKeyMigrateCommand() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "key-migrate",
-		Short: "Run Database key migration",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx, cancel := context.WithCancel(cmd.Context())
-			defer cancel()
-
-			contexts := []string{
-				// this is ordered to put the
-				// (presumably) biggest/most important
-				// subsets first.
-				"blockstore",
-				"state",
-				"peerstore",
-				"tx_index",
-				"evidence",
-				"light",
-			}
-
-			for idx, dbctx := range contexts {
-				logger.Info("beginning a key migration",
-					"dbctx", dbctx,
-					"num", idx+1,
-					"total", len(contexts),
-				)
-
-				db, err := cfg.DefaultDBProvider(&cfg.DBContext{
-					ID:     dbctx,
-					Config: config,
-				})
-
-				if err != nil {
-					return fmt.Errorf("constructing database handle: %w", err)
-				}
-
-				if err = keymigrate.Migrate(ctx, db); err != nil {
-					return fmt.Errorf("running migration for context %q: %w",
-						dbctx, err)
-				}
-			}
-
-			logger.Info("completed database migration successfully")
-
-			return nil
-		},
-	}
-
-	// allow database info to be overridden via cli
-	addDBFlags(cmd)
-
-	return cmd
-}

cmd/tendermint/commands/light.go

@@ -1,18 +1,18 @@
 package commands
 
 import (
+	"bufio"
 	"context"
 	"errors"
 	"fmt"
 	"net/http"
 	"os"
-	"os/signal"
 	"path/filepath"
 	"strings"
-	"syscall"
 	"time"
 
 	"github.com/spf13/cobra"
+
 	dbm "github.com/tendermint/tm-db"
 
 	"github.com/tendermint/tendermint/libs/log"
@@ -67,8 +67,7 @@ var (
 	trustedHash    []byte
 	trustLevelStr  string
 
-	logLevel  string
-	logFormat string
+	verbose bool
 
 	primaryKey   = []byte("primary")
 	witnessesKey = []byte("witnesses")
@@ -92,8 +91,7 @@ func init() {
 		"trusting period that headers can be verified within. Should be significantly less than the unbonding period")
 	LightCmd.Flags().Int64Var(&trustedHeight, "height", 1, "Trusted header's height")
 	LightCmd.Flags().BytesHexVar(&trustedHash, "hash", []byte{}, "Trusted header's hash")
-	LightCmd.Flags().StringVar(&logLevel, "log-level", log.LogLevelInfo, "The logging level (debug|info|warn|error|fatal)")
-	LightCmd.Flags().StringVar(&logFormat, "log-format", log.LogFormatPlain, "The logging format (text|json)")
+	LightCmd.Flags().BoolVar(&verbose, "verbose", false, "Verbose output")
 	LightCmd.Flags().StringVar(&trustLevelStr, "trust-level", "1/3",
 		"trust level. Must be between 1/3 and 3/3",
 	)
@@ -103,10 +101,15 @@ func init() {
 }
 
 func runProxy(cmd *cobra.Command, args []string) error {
-	logger, err := log.NewDefaultLogger(logFormat, logLevel, false)
-	if err != nil {
-		return err
+	// Initialize logger.
+	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
+	var option log.Option
+	if verbose {
+		option, _ = log.AllowLevel("debug")
+	} else {
+		option, _ = log.AllowLevel("info")
 	}
+	logger = log.NewFilter(logger, option)
 
 	chainID = args[0]
 	logger.Info("Creating client...", "chainID", chainID)
@@ -145,7 +148,25 @@ func runProxy(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("can't parse trust level: %w", err)
 	}
 
-	options := []light.Option{light.Logger(logger)}
+	options := []light.Option{
+		light.Logger(logger),
+		light.ConfirmationFunction(func(action string) bool {
+			fmt.Println(action)
+			scanner := bufio.NewScanner(os.Stdin)
+			for {
+				scanner.Scan()
+				response := scanner.Text()
+				switch response {
+				case "y", "Y":
+					return true
+				case "n", "N":
+					return false
+				default:
+					fmt.Println("please input 'Y' or 'n' and press ENTER")
+				}
+			}
+		}),
+	}
 
 	if sequential {
 		options = append(options, light.SequentialVerification())
@@ -153,21 +174,31 @@ func runProxy(cmd *cobra.Command, args []string) error {
 		options = append(options, light.SkippingVerification(trustLevel))
 	}
 
-	// Initiate the light client. If the trusted store already has blocks in it, this
-	// will be used else we use the trusted options.
-	c, err := light.NewHTTPClient(
-		context.Background(),
-		chainID,
-		light.TrustOptions{
-			Period: trustingPeriod,
-			Height: trustedHeight,
-			Hash:   trustedHash,
-		},
-		primaryAddr,
-		witnessesAddrs,
-		dbs.New(db),
-		options...,
-	)
+	var c *light.Client
+	if trustedHeight > 0 && len(trustedHash) > 0 { // fresh installation
+		c, err = light.NewHTTPClient(
+			context.Background(),
+			chainID,
+			light.TrustOptions{
+				Period: trustingPeriod,
+				Height: trustedHeight,
+				Hash:   trustedHash,
+			},
+			primaryAddr,
+			witnessesAddrs,
+			dbs.New(db),
+			options...,
+		)
+	} else { // continue from latest state
+		c, err = light.NewHTTPClientFromTrustedStore(
+			chainID,
+			trustingPeriod,
+			primaryAddr,
+			witnessesAddrs,
+			dbs.New(db),
+			options...,
+		)
+	}
 	if err != nil {
 		return err
 	}
@@ -189,16 +220,12 @@ func runProxy(cmd *cobra.Command, args []string) error {
 	}
 
 	// Stop upon receiving SIGTERM or CTRL-C.
-	tmos.TrapSignal(cmd.Context(), logger, func() {
+	tmos.TrapSignal(logger, func() {
 		p.Listener.Close()
 	})
 
-	// this might be redundant to the above, eventually.
-	ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM)
-	defer cancel()
-
 	logger.Info("Starting proxy...", "laddr", listenAddr)
-	if err := p.ListenAndServe(ctx); err != http.ErrServerClosed {
+	if err := p.ListenAndServe(); err != http.ErrServerClosed {
 		// Error starting or closing listener:
 		logger.Error("proxy ListenAndServe", "err", err)
 	}

cmd/tendermint/commands/probe_upnp.go

@@ -0,0 +1,34 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	tmjson "github.com/tendermint/tendermint/libs/json"
+	"github.com/tendermint/tendermint/p2p/upnp"
+)
+
+// ProbeUpnpCmd adds capabilities to test the UPnP functionality.
+var ProbeUpnpCmd = &cobra.Command{
+	Use:     "probe-upnp",
+	Aliases: []string{"probe_upnp"},
+	Short:   "Test UPnP functionality",
+	RunE:    probeUpnp,
+	PreRun:  deprecateSnakeCase,
+}
+
+func probeUpnp(cmd *cobra.Command, args []string) error {
+	capabilities, err := upnp.Probe(logger)
+	if err != nil {
+		fmt.Println("Probe failed: ", err)
+	} else {
+		fmt.Println("Probe success!")
+		jsonBytes, err := tmjson.Marshal(capabilities)
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(jsonBytes))
+	}
+	return nil
+}