Fix execution.go

.circleci/config.yml

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

.github/CODEOWNERS

@@ -7,6 +7,4 @@
 # 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 @tendermint/tendermint-engineering
-
-/spec @ebuchman @tendermint/tendermint-research @tendermint/tendermint-engineering
+*       @alexanderbez @cmwaters @ebuchman @marbar3778 @tessr @tychoish

.github/ISSUE_TEMPLATE/bug-report.md

@@ -1,18 +1,13 @@
 ---
-name: Bug report
+name: Bug Report
 about: Create a report to help us squash bugs!
 
 ---
 <!--
-
 Please fill in as much of the template below as you can.
 
-If you have general questions, please create a new discussion:
-https://github.com/tendermint/tendermint/discussions
-
-Be ready for followup questions, and please respond in a timely manner. We might
-ask you to provide additional logs and data (tendermint & app).
-
+Be ready for followup questions, and please respond in a timely
+manner. We might ask you to provide additional logs and data (tendermint & app).
 -->
 
 **Tendermint version** (use `tendermint version` or `git rev-parse --verify HEAD` if installed from source):

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Ask a question
-    url: https://github.com/tendermint/tendermint/discussions
-    about: Please ask and answer questions here

.github/ISSUE_TEMPLATE/feature-request.md

@@ -1,5 +1,5 @@
 ---
-name: Feature request
+name: Feature Request
 about: Create a proposal to request a feature
 
 ---
@@ -25,3 +25,12 @@ Are there any disadvantages of including this feature? -->
 ## Proposal
 
 <!-- Detailed description of requirements of implementation -->
+
+____
+
+#### For Admin Use
+
+- [ ] Not duplicate issue
+- [ ] Appropriate labels applied
+- [ ] Appropriate contributors tagged
+- [ ] Contributor assigned/self-assigned

.github/ISSUE_TEMPLATE/proposal.md

@@ -1,28 +0,0 @@
----
-name: Protocol change proposal
-about: Create a proposal to request a change to the protocol
-
----
-
-<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺ 
-v                            ✰  Thanks for opening an issue! ✰    
-v    Before smashing the submit button please review the template.
-v    Word of caution: Under-specified proposals may be rejected summarily 
-☺ > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >  -->
-
-# Protocol Change Proposal
-
-## Summary
-
-<!-- Short, concise description of the proposed change -->
-
-## Problem Definition
-
-<!-- Why do we need this change? 
-What problems may be addressed by introducing this change?
-What benefits does Tendermint stand to gain by including this change?
-Are there any disadvantages of including this change? -->
-
-## Proposal
-
-<!-- Detailed description of requirements of implementation -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,32 +1,7 @@
-<!--
+## Description
 
-Please add a reference to the issue that this PR addresses and indicate which
-files are most critical to review. If it fully addresses a particular issue,
-please include "Closes #XXX" (where "XXX" is the issue number).
+_Please add a description of the changes that this PR introduces and the files that
+are the most critical to review._ 
 
-If this PR is non-trivial/large/complex, please ensure that you have either
-created an issue that the team's had a chance to respond to, or had some
-discussion with the team prior to submitting substantial pull requests. The team
-can be reached via GitHub Discussions or the Cosmos Network Discord server in
-the #tendermint-core channel. GitHub Discussions is preferred over Discord as it
-allows us to keep track of conversations topically.
-https://github.com/tendermint/tendermint/discussions
-
-If the work in this PR is not aligned with the team's current priorities, please
-be advised that it may take some time before it is merged - especially if it has
-not yet been discussed with the team.
-
-See the project board for the team's current priorities:
-https://github.com/orgs/tendermint/projects/15/views/5
-
--->
-
----
-
-#### PR checklist
-
-- [ ] Tests written/updated, or no tests needed
-- [ ] `CHANGELOG_PENDING.md` updated, or no changelog entry needed
-- [ ] Updated relevant documentation (`docs/`) and code comments, or no
-      documentation updates needed
+Closes: #XXX
 

.github/auto-comment.yml

@@ -0,0 +1,16 @@
+pullRequestOpened: |
+  :wave: Thanks for creating a PR!   
+
+  Before we can merge this PR, please make sure that all the following items have been 
+  checked off. If any of the checklist items are not applicable, please leave them but
+  write a little note why.   
+
+  - [ ] Wrote tests  
+  - [ ] Updated CHANGELOG_PENDING.md   
+  - [ ] Linked to Github issue with discussion and accepted design OR link to spec that describes this work.  
+  - [ ] Updated relevant documentation (`docs/`) and code comments  
+  - [ ] Re-reviewed `Files changed` in the Github PR explorer  
+  - [ ] Applied Appropriate Labels  
+
+
+  Thank you for your contribution to Tendermint! :rocket:   

.github/codecov.yml

@@ -1,25 +0,0 @@
-coverage:
-  precision: 2
-  round: down
-  range: "70...100"
-  status:
-    project:
-      default:
-        threshold: 20%
-    patch: off
-    changes: off
-
-github_checks:
-  annotations: false
-
-comment: false
-
-ignore:
-  - "docs"
-  - "DOCKER"
-  - "scripts"
-  - "**/*.pb.go"
-  - "libs/pubsub/query/query.peg.go"
-  - "*.md"
-  - "*.rst"
-  - "*.yml"

.github/dependabot.yml

@@ -3,49 +3,25 @@ updates:
   - package-ecosystem: github-actions
     directory: "/"
     schedule:
-      interval: weekly
-    target-branch: "main"
+      interval: daily
+      time: "11:00"
     open-pull-requests-limit: 10
-    labels:
-      - T:dependencies
-      - S:automerge
-
-  - package-ecosystem: github-actions
-    directory: "/"
-    schedule:
-      interval: weekly
-    target-branch: "v0.34.x"
-    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: weekly
-    target-branch: "main"
+      interval: daily
+      time: "11:00"
     open-pull-requests-limit: 10
+    reviewers:
+      - melekes
+      - tessr
     labels:
       - T:dependencies
-      - S:automerge
-
-  - package-ecosystem: gomod
-    directory: "/"
-    schedule:
-      interval: weekly
-    target-branch: "v0.34.x"
-    open-pull-requests-limit: 10
-    labels:
-      - T:dependencies
-      - S:automerge

.github/issue_template.md

@@ -1,6 +0,0 @@
-<!--
-
-If you want to ask a general question, please create a new discussion instead of
-an issue: https://github.com/tendermint/tendermint/discussions
-
--->

.github/linters/markdownlint.yml

@@ -1,15 +0,0 @@
-# markdownlint configuration for Super-Linter
-# - https://github.com/DavidAnson/markdownlint
-# - https://github.com/github/super-linter
-
-# Default state for all rules
-default: true
-
-# See https://github.com/DavidAnson/markdownlint#rules--aliases for rules
-MD007: {"indent": 4}
-MD013: false
-MD024: {siblings_only: true}
-MD025: false
-MD033: {no-inline-html: false}
-no-hard-tabs: false
-whitespace: false

.github/linters/yaml-lint.yml

@@ -1,9 +0,0 @@
----
-# Default rules for YAML linting from super-linter.
-# See: See https://yamllint.readthedocs.io/en/stable/rules.html
-extends: default
-rules:
-  document-end: disable
-  document-start: disable
-  line-length: disable
-  truthy: disable

.github/mergify.yml

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

.github/workflows/build.yml

@@ -1,82 +0,0 @@
-name: Build
-# Tests runs different tests (test_abci_apps, test_abci_cli, test_apps)
-# This workflow runs on every push to main 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:
-      - main
-      - 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@v3
-        with:
-          go-version: "1.17"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        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@v3
-        with:
-          go-version: "1.17"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        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@v3
-        with:
-          go-version: "1.17"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        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 != ''"

.github/workflows/check-generated.yml

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

.github/workflows/coverage.yml

@@ -0,0 +1,123 @@
+name: Test Coverage
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+      - release/**
+
+jobs:
+  split-test-files:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - 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.15.4"
+      - uses: actions/checkout@v2
+      - 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.15.4"
+      - uses: actions/checkout@v2
+      - 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: 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
+      - 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.0.13
+        with:
+          file: ./coverage.txt
+        if: env.GIT_DIFF

.github/workflows/docker.yml

@@ -1,19 +1,20 @@
-name: Docker
-# Build & Push rebuilds the Tendermint docker image on every push to main and creation of tags
-# and pushes the image to https://hub.docker.com/r/tendermint/tendermint
+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:
-      - main
+      - master
     tags:
-      - "v[0-9]+.[0-9]+.[0-9]+"  # Push events to matching v*, i.e. v1.0, v20.15.10
-      - "v[0-9]+.[0-9]+.[0-9]+-rc*"  # Push events to matching v*, i.e. v1.0-rc1, v20.15.10-rc5
+      - "v[0-9]+.[0-9]+.[0-9]+" # Push events to matching v*, i.e. v1.0, v20.15.10
+      - "v[0-9]+.[0-9]+.[0-9]+-rc*" # Push events to matching v*, i.e. v1.0-rc1, v20.15.10-rc5
 
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@master
       - name: Prepare
         id: prep
         run: |
@@ -38,18 +39,18 @@ jobs:
         with:
           platforms: all
 
-      - name: Set up Docker Build
-        uses: docker/setup-buildx-action@v2.0.0
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
 
       - name: Login to DockerHub
         if: ${{ github.event_name != 'pull_request' }}
-        uses: docker/login-action@v2.0.0
+        uses: docker/login-action@v1
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Publish to Docker Hub
-        uses: docker/build-push-action@v3.1.0
+        uses: docker/build-push-action@v2
         with:
           context: .
           file: ./DOCKER/Dockerfile

.github/workflows/docs-deployment.yml

@@ -1,62 +0,0 @@
-# Build and deploy the docs.tendermint.com website content.
-# The static content is published to GitHub Pages.
-#
-# For documentation build info, see docs/DOCS_README.md.
-name: Build static documentation site
-on:
-  workflow_dispatch:  # allow manual updates
-  push:
-    branches:
-      - main
-    paths:
-      - docs/**
-      - spec/**
-
-jobs:
-  # This is split into two jobs so that the build, which runs npm, does not
-  # have write access to anything. The deploy requires write access to publish
-  # to the branch used by GitHub Pages, however, so we can't just make the
-  # whole workflow read-only.
-  build:
-    name: VuePress build
-    runs-on: ubuntu-latest
-    container:
-      image: alpine:latest
-    permissions:
-      contents: read
-    steps:
-      - name: Install generator dependencies
-        run: |
-          apk add --no-cache make bash git npm
-      - uses: actions/checkout@v3
-        with:
-          # We need to fetch full history so the backport branches for previous
-          # versions will be available for the build.
-          fetch-depth: 0
-      - name: Build documentation
-        run: |
-          git config --global --add safe.directory "$PWD"
-          make build-docs
-      - uses: actions/upload-artifact@v3
-        with:
-          name: build-output
-          path: ~/output/
-
-  deploy:
-    name: Deploy to GitHub Pages
-    runs-on: ubuntu-latest
-    needs: build
-    permissions:
-      contents: write
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/download-artifact@v3
-        with:
-          name: build-output
-          path: ~/output
-      - name: Deploy to GitHub Pages
-        uses: JamesIves/github-pages-deploy-action@v4
-        with:
-          branch: 'docs-tendermint-com'
-          folder: ~/output
-          single-commit: true

.github/workflows/docs-toc.yml

@@ -1,21 +0,0 @@
-# TODO(thane): Re-enable once we've pulled in the ADRs and RFCs from master.
-# Verify that important design docs have ToC entries.
-#name: Check documentation ToC
-#on:
-#  pull_request:
-#    push:
-#      branches:
-#        - main
-#
-#jobs:
-#  check:
-#    runs-on: ubuntu-latest
-#    steps:
-#      - uses: actions/checkout@v3
-#      - uses: technote-space/get-diff-action@v6
-#        with:
-#          PATTERNS: |
-#            docs/architecture/**
-#            docs/rfc/**
-#      - run: ./docs/presubmit.sh
-#        if: env.GIT_DIFF

.github/workflows/e2e-manual.yml

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

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

@@ -1,10 +1,12 @@
-# Runs randomly generated E2E testnets nightly on the 0.34.x branch.
+# Runs randomly generated E2E testnets nightly
+# on the 0.34.x release branch
 
-# !! This file should be kept in sync with the e2e-nightly-main.yml file,
-# modulo changes to the version labels.
+# !! If you change something in this file, you probably want
+# to update the e2e-nightly-master workflow as well!
 
 name: e2e-nightly-34x
 on:
+  workflow_dispatch: # allow running workflow manually, in theory
   schedule:
     - cron: '0 2 * * *'
 
@@ -15,15 +17,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        group: ['00', '01', '02', '03', "04"]
+        group: ['00', '01', '02', '03']
     runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
+          go-version: '^1.15.4'
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
         with:
           ref: 'v0.34.x'
 
@@ -35,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
@@ -47,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@e9db0ef
         env:
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_CHANNEL: tendermint-internal
@@ -56,3 +58,19 @@ jobs:
           SLACK_COLOR: danger
           SLACK_MESSAGE: Nightly E2E tests failed on v0.34.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@ae4223259071871559b6e9d08b24a63d71b3f0c0
+        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.34.x
+          SLACK_FOOTER: ''

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

@@ -1,73 +1,73 @@
-# Runs randomly generated E2E testnets nightly on main
+# Runs randomly generated E2E testnets nightly on master
 
-# !! Relevant changes to this file should be propagated to the e2e-nightly-<V>x
-# files for the supported backport branches, when appropriate, modulo version
-# markers.
+# !! If you change something in this file, you probably want
+# to update the e2e-nightly-34x workflow as well!
 
-name: e2e-nightly-main
+name: e2e-nightly-master
 on:
+  workflow_dispatch: # allow running workflow manually
   schedule:
     - 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:
-        group: ['00', '01', '02', '03', "04"]
+        group: ['00', '01', '02', '03']
     runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
+          go-version: '1.15'
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
       - 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 5 -d networks/nightly/
+        run: ./build/generator -g 4 -d networks/nightly
 
-      - name: Run ${{ matrix.p2p }} p2p testnets
+      - name: Run testnets in group ${{ matrix.group }}
         working-directory: test/e2e
         run: ./run-multiple.sh networks/nightly/*-group${{ matrix.group }}-*.toml
 
-  e2e-nightly-fail:
-    needs: e2e-nightly-test
+  e2e-nightly-fail-2:
+    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@ae4223259071871559b6e9d08b24a63d71b3f0c0
         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 main
+          SLACK_MESSAGE: Nightly E2E tests failed on master
           SLACK_FOOTER: ''
 
-  e2e-nightly-success:  # may turn this off once they seem to pass consistently
-    needs: e2e-nightly-test
+  e2e-nightly-success: # may turn this off once they seem to pass consistently
+    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@ae4223259071871559b6e9d08b24a63d71b3f0c0
         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 main
+          SLACK_MESSAGE: Nightly E2E tests passed on master
           SLACK_FOOTER: ''

.github/workflows/e2e.yml

@@ -1,12 +1,11 @@
 name: e2e
-# Runs the CI end-to-end test network on all pushes to main or release branches
+# Runs the CI end-to-end test network on all pushes to master or release branches
 # and every pull request, but only if any Go files have been changed.
 on:
-  workflow_dispatch:  # allow running workflow manually
   pull_request:
   push:
     branches:
-      - main
+      - master
       - release/**
 
 jobs:
@@ -14,11 +13,11 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 15
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: '^1.15.4'
+      - uses: actions/checkout@v2
+      - uses: technote-space/get-diff-action@v4
         with:
           PATTERNS: |
             **/**.go
@@ -28,10 +27,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,27 +1,23 @@
 # Runs fuzzing nightly.
-name: Fuzz Tests
+name: fuzz-nightly
 on:
-  workflow_dispatch:  # allow running workflow manually
+  workflow_dispatch: # allow running workflow manually
   schedule:
     - cron: '0 3 * * *'
-  pull_request:
-    branches: [main]
-    paths:
-      - "test/fuzz/**/*.go"
 
 jobs:
   fuzz-nightly-test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v3
+      - uses: actions/setup-go@v2
         with:
-          go-version: '1.17'
+          go-version: '1.15'
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v2
 
       - name: Install go-fuzz
         working-directory: test/fuzz
-        run: go install github.com/dvyukov/go-fuzz/go-fuzz@latest github.com/dvyukov/go-fuzz/go-fuzz-build@latest
+        run: go get -u github.com/dvyukov/go-fuzz/go-fuzz github.com/dvyukov/go-fuzz/go-fuzz-build
 
       - name: Fuzz mempool
         working-directory: test/fuzz
@@ -49,18 +45,18 @@ jobs:
         continue-on-error: true
 
       - name: Archive crashers
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v2
         with:
           name: crashers
           path: test/fuzz/**/crashers
-          retention-days: 3
+          retention-days: 1
 
       - name: Archive suppressions
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v2
         with:
           name: suppressions
           path: test/fuzz/**/suppressions
-          retention-days: 3
+          retention-days: 1
 
       - name: Set crashers count
         working-directory: test/fuzz
@@ -76,7 +72,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Notify Slack if any crashers
-        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        uses: rtCamp/action-slack-notify@ae4223259071871559b6e9d08b24a63d71b3f0c0
         env:
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_CHANNEL: tendermint-internal

.github/workflows/janitor.yml

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

.github/workflows/linkchecker.yml

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

.github/workflows/lint.yaml

@@ -0,0 +1,29 @@
+name: Lint
+# Lint runs golangci-lint over the entire Tendermint repository
+# This workflow is run on every pull request and push to master
+# The `golangci` job will pass without running if no *.{go, mod, sum} files have been modified.
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+jobs:
+  golangci:
+    name: golangci-lint
+    runs-on: ubuntu-latest
+    timeout-minutes: 4
+    steps:
+      - uses: actions/checkout@v2
+      - uses: technote-space/get-diff-action@v4
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - uses: golangci/golangci-lint-action@v2.5.1
+        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.38
+          args: --timeout 10m
+          github-token: ${{ secrets.github_token }}
+        if: env.GIT_DIFF

.github/workflows/lint.yml

@@ -1,40 +0,0 @@
-name: Golang Linter
-# Lint runs golangci-lint over the entire Tendermint repository.
-#
-# This workflow is run on every pull request and push to main.
-#
-# The `golangci` job will pass without running if no *.{go, mod, sum}
-# files have been modified.
-#
-# To run this locally, simply run `make lint` from the root of the repo.
-
-on:
-  pull_request:
-  push:
-    branches:
-      - main
-jobs:
-  golangci:
-    name: golangci-lint
-    runs-on: ubuntu-latest
-    timeout-minutes: 8
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v3
-        with:
-          go-version: '1.17'
-      - uses: technote-space/get-diff-action@v6
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - uses: golangci/golangci-lint-action@v3
-        with:
-          # Required: the version of golangci-lint is required and
-          # must be specified without patch version: we always use the
-          # latest patch version.
-          version: v1.45
-          args: --timeout 10m
-          github-token: ${{ secrets.github_token }}
-        if: env.GIT_DIFF

.github/workflows/linter.yml

@@ -1,17 +1,16 @@
-name: Markdown Linter
+name: Lint
 on:
   push:
     branches:
-      - main
+      - master
     paths:
       - "**.md"
       - "**.yml"
       - "**.yaml"
   pull_request:
-    branches: [main]
+    branches: [master]
     paths:
       - "**.md"
-      - "**.yml"
 
 jobs:
   build:
@@ -19,14 +18,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
       - name: Lint Code Base
-        uses: docker://github/super-linter:v4
+        uses: docker://github/super-linter:v3
         env:
+          LINTER_RULES_PATH: .
           VALIDATE_ALL_CODEBASE: true
-          DEFAULT_BRANCH: main
+          DEFAULT_BRANCH: master
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           VALIDATE_MD: true
-          VALIDATE_OPENAPI: true
+          MARKDOWN_CONFIG_FILE: .markdownlint.yml
+          VALIDATE_OPAENAPI: true
           VALIDATE_YAML: true
-          YAML_CONFIG_FILE: yaml-lint.yml

.github/workflows/markdown-links.yml

@@ -1,23 +0,0 @@
-name: Check Markdown links
-
-on:
-  push:
-    branches:
-      - main
-  pull_request:
-    branches: [main]
-
-jobs:
-  markdown-link-check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        with:
-          PATTERNS: |
-            **/**.md
-      - uses: creachadair/github-action-markdown-link-check@master
-        with:
-          check-modified-files-only: 'yes'
-          config-file: '.md-link-check.json'
-        if: env.GIT_DIFF

.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@master
+      - 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
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Publish to Docker Hub
+        uses: docker/build-push-action@v2
+        with:
+          context: ./tools/proto
+          file: ./tools/proto/Dockerfile
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.prep.outputs.tags }}

.github/workflows/proto-lint.yml

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

.github/workflows/proto.yml

@@ -0,0 +1,22 @@
+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:
+  pull_request:
+    paths:
+      - "**.proto"
+jobs:
+  proto-lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 4
+    steps:
+      - uses: actions/checkout@master
+      - name: lint
+        run: make proto-lint
+  proto-breakage:
+    runs-on: ubuntu-latest
+    timeout-minutes: 4
+    steps:
+      - uses: actions/checkout@master
+      - name: check-breakage
+        run: make proto-check-breaking-ci

.github/workflows/release.yml

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

.github/workflows/stale.yml

@@ -7,14 +7,12 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@v5
+      - uses: actions/stale@v3
         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,34 +1,146 @@
-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:
-      - main
+      - master
       - release/**
 
 jobs:
-  tests:
+  cleanup-runs:
     runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        part: ["00", "01", "02", "03", "04", "05"]
     steps:
-      - uses: actions/setup-go@v3
+      - uses: rokroskar/workflow-run-cleanup-action@master
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
+    if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/master'"
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/setup-go@v2
         with:
-          go-version: "1.17"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
+          go-version: "^1.15.4"
+      - uses: actions/checkout@v2
+      - 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=6
+      - name: install
+        run: make install install_abci
+        if: "env.GIT_DIFF != ''"
+      - uses: actions/cache@v2.1.4
+        with:
+          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.4
+        with:
+          path: ~/go/bin
+          key: ${{ runner.os }}-${{ github.sha }}-tm-binary
+        if: env.GIT_DIFF
+
+  test_abci_apps:
+    runs-on: ubuntu-latest
+    needs: build
+    timeout-minutes: 5
+    steps:
+      - uses: actions/setup-go@v2
+        with:
+          go-version: "^1.15.4"
+      - uses: actions/checkout@v2
+      - uses: technote-space/get-diff-action@v4
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - uses: actions/cache@v2.1.4
+        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.4
+        with:
+          path: ~/go/bin
+          key: ${{ runner.os }}-${{ github.sha }}-tm-binary
+        if: env.GIT_DIFF
+      - name: test_abci_apps
+        run: abci/tests/test_app/test.sh
+        shell: bash
+        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.15.4"
+      - uses: actions/checkout@v2
+      - uses: technote-space/get-diff-action@v4
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - uses: actions/cache@v2.1.4
+        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.4
+        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.15.4"
+      - uses: actions/checkout@v2
+      - uses: technote-space/get-diff-action@v4
+        with:
+          PATTERNS: |
+            **/**.go
+            go.mod
+            go.sum
+      - uses: actions/cache@v2.1.4
+        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.4
+        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

@@ -1,56 +1,58 @@
-*.bak
-*.iml
-*.swo
 *.swp
-*/.glide
-*/vendor
-.DS_Store
+*.swo
 .bak
-.idea/
-.revision
-.tendermint
-.tendermint-lite
-.terraform
-.vagrant
-.vendor-new/
-.vscode/
-abci/abci-cli
-addrbook.json
-artifacts/*
+*.bak
+.DS_Store
 build/*
+rpc/test/.tendermint
+.tendermint
+remote_dump
+.revision
+vendor
+.vagrant
+test/e2e/build
+test/maverick/maverick
+test/e2e/networks/*/
+test/p2p/data/
+test/logs
 coverage.txt
-docs/.vuepress/dist
 docs/_build
 docs/dist
+docs/.vuepress/dist
+*.log
+abci-cli
 docs/node_modules/
-docs/spec
-docs/.vuepress/public/rpc
 index.html.md
-libs/pubsub/query/fuzz_test/output
-profile\.out
-remote_dump
-rpc/test/.tendermint
-scripts/cutWALUntil/cutWALUntil
+
 scripts/wal2json/wal2json
+scripts/cutWALUntil/cutWALUntil
+
+.idea/
+*.iml
+
+.vscode/
+
+libs/pubsub/query/fuzz_test/output
 shunit2
+
+.tendermint-lite
+addrbook.json
+
+*/vendor
+.vendor-new/
+*/.glide
+.terraform
 terraform.tfstate
 terraform.tfstate.backup
 terraform.tfstate.d
-test/app/grpc_client
+profile\.out
 test/e2e/build
 test/e2e/networks/*/
 test/logs
+test/maverick/maverick
 test/p2p/data/
 vendor
 test/fuzz/**/corpus
 test/fuzz/**/crashers
 test/fuzz/**/suppressions
 test/fuzz/**/*.zip
-proto/spec/**/*.pb.go
-*.aux
-*.bbl
-*.blg
-*.log
-*.pdf
-*.gz
-*.dvi

.golangci.yml

@@ -1,6 +1,5 @@
 linters:
   enable:
-    - asciicheck
     - bodyclose
     - deadcode
     - depguard
@@ -8,39 +7,56 @@ linters:
     - dupl
     - errcheck
     - exportloopref
+    # - funlen
+    # - gochecknoglobals
+    # - gochecknoinits
     - goconst
+    - gocritic
+    # - gocyclo
+    # - godox
     - gofmt
     - goimports
-    - revive
+    - golint
     - gosec
     - gosimple
     - govet
     - ineffassign
+    # - interfacer
+    - lll
     - misspell
+    # - maligned
     - nakedret
-    - nolintlint
     - prealloc
+    # - scopelint
     - staticcheck
     - structcheck
     - stylecheck
     - typecheck
     - unconvert
+    # - unparam
     - unused
     - varcheck
+    # - whitespace
+    # - wsl
+    # - gocognit
+    - nolintlint
 
 issues:
   exclude-rules:
     - path: _test\.go
       linters:
         - gosec
+    - linters:
+        - lll
+      source: "https://"
   max-same-issues: 50
 
 linters-settings:
   dogsled:
     max-blank-identifiers: 3
-  golint:
-    min-confidence: 0
   maligned:
     suggest-new: true
-  misspell:
-    locale: US
+  # govet:
+  #   check-shadowing: true
+  golint:
+    min-confidence: 0

.goreleaser.yml

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

.markdownlint.yml

@@ -1,12 +1,5 @@
-# markdownlint configuration
-# https://github.com/DavidAnson/markdownlint
-
-# Default state for all rules
-default: true
-
-# See https://github.com/DavidAnson/markdownlint#rules--aliases for rules
-MD001: false
-MD007: {indent: 4}
+default: true,
+MD007: { "indent": 4 }
 MD013: false
 MD024: { siblings_only: true }
 MD025: false

.md-link-check.json

@@ -1,6 +0,0 @@
-{
-    "retryOn429": true,
-    "retryCount": 5,
-    "fallbackRetryDelay": "30s",
-    "aliveStatusCodes": [200, 206, 503]
-}

.mergify.yml

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

.vscode/settings.json

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

CHANGELOG.md

@@ -2,82 +2,6 @@
 
 Friendly reminder, we have a [bug bounty program](https://hackerone.com/cosmos).
 
-## v0.34.20
-
-Special thanks to external contributors on this release: @joeabbey @yihuang
-
-This release introduces a prioritized mempool. Further notes can be found in UPGRADING.md.
-
-NOTE: There's a known issue when combining the prioritized mempool with the ABCI socket client, that the team are curently working to resolve. Read more about the issue [here](https://github.com/tendermint/tendermint/pull/9030).
-
-### BUG FIXES
-
-- [blocksync] [\#8496](https://github.com/tendermint/tendermint/pull/8496) validate block against state before persisting it to disk (@cmwaters)
-- [indexer] [#8625](https://github.com/tendermint/tendermint/pull/8625) Fix overriding tx index of duplicated txs. (@yihuang)
-- [mempool] [\#8962](https://github.com/tendermint/tendermint/issues/8962) Backport priority mempool fixes from v0.35.x to v0.34.x (@creachadair).
-
-### FEATURES
-
-- [cli] [\#8674] Add command to force compact goleveldb databases (@cmwaters)
-- [mempool] [\#8695] Port back the priority mempool. (@alexanderbez, @jmalicevic, @cmwaters)
-
-### IMPROVEMENTS
-
-- [logging] [\#8845](https://github.com/tendermint/tendermint/issues/8845) Add "Lazy" Stringers to defer Sprintf and Hash until logs print. (@joeabbey)
-
-## v0.34.19
-
-### BUG FIXES
-
-- [cli] [\#8270](https://github.com/tendermint/tendermint/issues/8270) fix reset commands (@alexanderbez).
-
-## v0.34.18
-
-### BREAKING CHANGES
-
-- CLI/RPC/Config
-    - [cli] [\#8258](https://github.com/tendermint/tendermint/pull/8258) Fix a bug in the cli that caused `unsafe-reset-all` to panic
-
-## v0.34.17
-
-### BREAKING CHANGES
-
-- CLI/RPC/Config
-
-   - [cli] [\#8081](https://github.com/tendermint/tendermint/issues/8081) make the reset command safe to use (@marbar3778).
-
-### BUG FIXES
-
-- [consensus] [\#8079](https://github.com/tendermint/tendermint/issues/8079) start the timeout ticker before relay (backport #7844) (@creachadair).
-- [consensus] [\#7992](https://github.com/tendermint/tendermint/issues/7992) [\#7994](https://github.com/tendermint/tendermint/issues/7994) change lock handling in handleMsg and reactor to alleviate issues gossiping during long ABCI calls (@williambanfield).
-
-## v0.34.16
-
-Special thanks to external contributors on this release: @yihuang
-
-### BUG FIXES
-
-- [consensus] [\#7617](https://github.com/tendermint/tendermint/issues/7617) calculate prevote message delay metric (backport #7551) (@williambanfield).
-- [consensus] [\#7631](https://github.com/tendermint/tendermint/issues/7631) check proposal non-nil in prevote message delay metric (backport #7625) (@williambanfield).
-- [statesync] [\#7885](https://github.com/tendermint/tendermint/issues/7885) statesync: assert app version matches (backport #7856) (@cmwaters).
-- [statesync] [\#7881](https://github.com/tendermint/tendermint/issues/7881) fix app hash in state rollback (backport #7837) (@cmwaters).
-- [cli] [#7837](https://github.com/tendermint/tendermint/pull/7837) fix app hash in state rollback. (@yihuang).
-
-## v0.34.15
-
-Special thanks to external contributors on this release: @thanethomson
-
-### BUG FIXES
-
-- [\#7368](https://github.com/tendermint/tendermint/issues/7368) cmd: add integration test for rollback functionality (@cmwaters).
-- [\#7309](https://github.com/tendermint/tendermint/issues/7309) pubsub: Report a non-nil error when shutting down (fixes #7306).
-- [\#7057](https://github.com/tendermint/tendermint/pull/7057) Import Postgres driver support for the psql indexer (@creachadair).
-- [\#7106](https://github.com/tendermint/tendermint/pull/7106) Revert mutex change to ABCI Clients (@tychoish).
-
-### IMPROVEMENTS
-
-- [config] [\#7230](https://github.com/tendermint/tendermint/issues/7230) rpc: Add experimental config params to allow for subscription buffer size control (@thanethomson).
-
 ## v0.34.14
 
 This release backports the `rollback` feature to allow recovery in the event of an incorrect app hash.
@@ -1766,7 +1690,7 @@ more details.
   - [rpc] [\#3269](https://github.com/tendermint/tendermint/issues/2826) Limit number of unique clientIDs with open subscriptions. Configurable via `rpc.max_subscription_clients`
   - [rpc] [\#3269](https://github.com/tendermint/tendermint/issues/2826) Limit number of unique queries a given client can subscribe to at once. Configurable via `rpc.max_subscriptions_per_client`.
   - [rpc] [\#3435](https://github.com/tendermint/tendermint/issues/3435) Default ReadTimeout and WriteTimeout changed to 10s. WriteTimeout can increased by setting `rpc.timeout_broadcast_tx_commit` in the config.
-  - [rpc/client] [\#3269](https://github.com/tendermint/tendermint/issues/3269) Update `EventsClient` interface to reflect new pubsub/eventBus API [ADR-33](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-033-pubsub.md). This includes `Subscribe`, `Unsubscribe`, and `UnsubscribeAll` methods.
+  - [rpc/client] [\#3269](https://github.com/tendermint/tendermint/issues/3269) Update `EventsClient` interface to reflect new pubsub/eventBus API [ADR-33](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-033-pubsub.md). This includes `Subscribe`, `Unsubscribe`, and `UnsubscribeAll` methods.
 
 * Apps
   - [abci] [\#3403](https://github.com/tendermint/tendermint/issues/3403) Remove `time_iota_ms` from BlockParams. This is a
@@ -1819,7 +1743,7 @@ more details.
 - [blockchain] [\#3358](https://github.com/tendermint/tendermint/pull/3358) Fix timer leak in `BlockPool` (@guagualvcha)
 - [cmd] [\#3408](https://github.com/tendermint/tendermint/issues/3408) Fix `testnet` command's panic when creating non-validator configs (using `--n` flag) (@srmo)
 - [libs/db/remotedb/grpcdb] [\#3402](https://github.com/tendermint/tendermint/issues/3402) Close Iterator/ReverseIterator after use
-- [libs/pubsub] [\#951](https://github.com/tendermint/tendermint/issues/951), [\#1880](https://github.com/tendermint/tendermint/issues/1880) Use non-blocking send when dispatching messages [ADR-33](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-033-pubsub.md)
+- [libs/pubsub] [\#951](https://github.com/tendermint/tendermint/issues/951), [\#1880](https://github.com/tendermint/tendermint/issues/1880) Use non-blocking send when dispatching messages [ADR-33](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-033-pubsub.md)
 - [lite] [\#3364](https://github.com/tendermint/tendermint/issues/3364) Fix `/validators` and `/abci_query` proxy endpoints
   (@guagualvcha)
 - [p2p/conn] [\#3347](https://github.com/tendermint/tendermint/issues/3347) Reject all-zero shared secrets in the Diffie-Hellman step of secret-connection
@@ -2517,7 +2441,7 @@ Special thanks to external contributors on this release:
 This release is mostly about the ConsensusParams - removing fields and enforcing MaxGas.
 It also addresses some issues found via security audit, removes various unused
 functions from `libs/common`, and implements
-[ADR-012](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-012-peer-transport.md).
+[ADR-012](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-012-peer-transport.md).
 
 BREAKING CHANGES:
 
@@ -2598,7 +2522,7 @@ BREAKING CHANGES:
   - [abci] Added address of the original proposer of the block to Header
   - [abci] Change ABCI Header to match Tendermint exactly
   - [abci] [\#2159](https://github.com/tendermint/tendermint/issues/2159) Update use of `Validator` (see
-    [ADR-018](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-018-ABCI-Validators.md)):
+    [ADR-018](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-018-ABCI-Validators.md)):
     - Remove PubKey from `Validator` (so it's just Address and Power)
     - Introduce `ValidatorUpdate` (with just PubKey and Power)
     - InitChain and EndBlock use ValidatorUpdate
@@ -2620,7 +2544,7 @@ BREAKING CHANGES:
   - [state] [\#1815](https://github.com/tendermint/tendermint/issues/1815) Validator set changes are now delayed by one block (!)
     - Add NextValidatorSet to State, changes on-disk representation of state
   - [state] [\#2184](https://github.com/tendermint/tendermint/issues/2184) Enforce ConsensusParams.BlockSize.MaxBytes (See
-    [ADR-020](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-020-block-size.md)).
+    [ADR-020](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-020-block-size.md)).
     - Remove ConsensusParams.BlockSize.MaxTxs
     - Introduce maximum sizes for all components of a block, including ChainID
   - [types] Updates to the block Header:
@@ -2631,7 +2555,7 @@ BREAKING CHANGES:
   - [consensus] [\#2203](https://github.com/tendermint/tendermint/issues/2203) Implement BFT time
     - Timestamp in block must be monotonic and equal the median of timestamps in block's LastCommit
   - [crypto] [\#2239](https://github.com/tendermint/tendermint/issues/2239) Secp256k1 signature changes (See
-    [ADR-014](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-014-secp-malleability.md)):
+    [ADR-014](https://github.com/tendermint/tendermint/blob/develop/docs/architecture/adr-014-secp-malleability.md)):
     - format changed from DER to `r || s`, both little endian encoded as 32 bytes.
     - malleability removed by requiring `s` to be in canonical form.
 

CHANGELOG_PENDING.md

@@ -1,6 +1,6 @@
 # Unreleased Changes
 
-## v0.34.21
+## v0.34.15
 
 Special thanks to external contributors on this release:
 
@@ -20,8 +20,9 @@ Friendly reminder, we have a [bug bounty program](https://hackerone.com/tendermi
 
 ### FEATURES
 
-- [#9083] backport cli command to reindex missed events (@cmwaters)
-
 ### IMPROVEMENTS
 
 ### BUG FIXES
+
+- [\#7057](https://github.com/tendermint/tendermint/pull/7057) Import Postgres driver support for the psql indexer (@creachadair).
+- [\#7106](https://github.com/tendermint/tendermint/pull/7106) Revert mutex change to ABCI Clients (@tychoish).

Makefile

@@ -1,6 +1,5 @@
 PACKAGES=$(shell go list ./...)
-BUILDDIR?=$(CURDIR)/build
-OUTPUT?=$(BUILDDIR)/tendermint
+OUTPUT?=build/tendermint
 
 BUILD_TAGS?=tendermint
 
@@ -14,6 +13,7 @@ endif
 LD_FLAGS = -X github.com/tendermint/tendermint/version.TMCoreSemVer=$(VERSION)
 BUILD_FLAGS = -mod=readonly -ldflags "$(LD_FLAGS)"
 HTTPS_GIT := https://github.com/tendermint/tendermint.git
+DOCKER_BUF := docker run -v $(shell pwd):/workspace --workdir /workspace bufbuild/buf
 CGO_ENABLED ?= 0
 
 # handle nostrip
@@ -70,59 +70,34 @@ install:
 	CGO_ENABLED=$(CGO_ENABLED) go install $(BUILD_FLAGS) -tags $(BUILD_TAGS) ./cmd/tendermint
 .PHONY: install
 
-
-###############################################################################
-###                                Mocks                                    ###
-###############################################################################
-
-mockery: 
-	go generate -run="./scripts/mockery_generate.sh" ./...
-.PHONY: mockery 
-
 ###############################################################################
 ###                                Protobuf                                 ###
 ###############################################################################
 
-check-proto-deps:
-ifeq (,$(shell which protoc-gen-gogofaster))
-	@go install github.com/gogo/protobuf/protoc-gen-gogofaster@latest
-endif
-.PHONY: check-proto-deps
+proto-all: proto-gen proto-lint proto-check-breaking
+.PHONY: proto-all
 
-check-proto-format-deps:
-ifeq (,$(shell which clang-format))
-	$(error "clang-format is required for Protobuf formatting. See instructions for your platform on how to install it.")
-endif
-.PHONY: check-proto-format-deps
-
-proto-gen: check-proto-deps
+proto-gen:
+	@docker pull -q tendermintdev/docker-build-proto
 	@echo "Generating Protobuf files"
-	@go run github.com/bufbuild/buf/cmd/buf generate
-	@mv ./proto/tendermint/abci/types.pb.go ./abci/types/
+	@docker run -v $(shell pwd):/workspace --workdir /workspace tendermintdev/docker-build-proto sh ./scripts/protocgen.sh
 .PHONY: proto-gen
 
-# These targets are provided for convenience and are intended for local
-# execution only.
-proto-lint: check-proto-deps
-	@echo "Linting Protobuf files"
-	@go run github.com/bufbuild/buf/cmd/buf lint
+proto-lint:
+	@$(DOCKER_BUF) check lint --error-format=json
 .PHONY: proto-lint
 
-proto-format: check-proto-format-deps
+proto-format:
 	@echo "Formatting Protobuf files"
-	@find . -name '*.proto' -path "./proto/*" -exec clang-format -i {} \;
+	docker run -v $(shell pwd):/workspace --workdir /workspace tendermintdev/docker-build-proto find ./ -not -path "./third_party/*" -name *.proto -exec clang-format -i {} \;
 .PHONY: proto-format
 
-proto-check-breaking: check-proto-deps
-	@echo "Checking for breaking changes in Protobuf files against local branch"
-	@echo "Note: This is only useful if your changes have not yet been committed."
-	@echo "      Otherwise read up on buf's \"breaking\" command usage:"
-	@echo "      https://docs.buf.build/breaking/usage"
-	@go run github.com/bufbuild/buf/cmd/buf breaking --against ".git"
+proto-check-breaking:
+	@$(DOCKER_BUF) check breaking --against-input .git#branch=master
 .PHONY: proto-check-breaking
 
 proto-check-breaking-ci:
-	@go run github.com/bufbuild/buf/cmd/buf breaking --against $(HTTPS_GIT)#branch=v0.34.x
+	@$(DOCKER_BUF) check breaking --against-input $(HTTPS_GIT)#branch=master
 .PHONY: proto-check-breaking-ci
 
 ###############################################################################
@@ -211,12 +186,12 @@ 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) ; \
-		mkdir -p ~/output/$${path_prefix} ; \
-		cp -r .vuepress/dist/* ~/output/$${path_prefix}/ ; \
-		cp ~/output/$${path_prefix}/index.html ~/output ; \
+	cd docs && \
+	while read p; do \
+		(git checkout $${p} . && npm install && VUEPRESS_BASE="/$${p}/" npm run build) ; \
+		mkdir -p ~/output/$${p} ; \
+		cp -r .vuepress/dist/* ~/output/$${p}/ ; \
+		cp ~/output/$${p}/index.html ~/output ; \
 	done < versions ;
 .PHONY: build-docs
 
@@ -287,25 +262,3 @@ endif
 contract-tests:
 	dredd
 .PHONY: contract-tests
-
-# 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.
-# Note we need to check for both in-package tests (.TestGoFiles) and
-# out-of-package tests (.XTestGoFiles).
-$(BUILDDIR)/packages.txt:$(GO_TEST_FILES) $(BUILDDIR)
-	go list -f "{{ if (or .TestGoFiles .XTestGoFiles) }}{{ .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=5m -race -coverprofile=$(BUILDDIR)/$*.profile.out

UPGRADING.md

@@ -2,28 +2,13 @@
 
 This guide provides instructions for upgrading to specific versions of Tendermint Core.
 
-## v0.34.20
-
-### Feature: Priority Mempool
-
-This release backports an implementation of the Priority Mempool from the v0.35
-branch. This implementation of the mempool permits the application to set a
-priority on each transaction during CheckTx, and during block selection the
-highest-priority transactions are chosen (subject to the constraints on size
-and gas cost).
-
-Operators can enable the priority mempool by setting `mempool.version` to
-`"v1"` in the `config.toml`. For more technical details about the priority
-mempool, see [ADR 067: Mempool
-Refactor](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-067-mempool-refactor.md).
-
 ## v0.34.0
 
 **Upgrading to Tendermint 0.34 requires a blockchain restart.**
 This release is not compatible with previous blockchains due to changes to
 the encoding format (see "Protocol Buffers," below) and the block header (see "Blockchain Protocol").
 
-Note also that Tendermint 0.34 also requires Go 1.15 or higher.
+Note also that Tendermint 0.34 also requires Go 1.15 or higher. 
 
 ### ABCI Changes
 
@@ -127,7 +112,7 @@ Tendermint 0.34 includes new and updated consensus parameters.
 
 #### Evidence Parameters
 
-* `MaxBytes`, which caps the total amount of evidence. The default is 1048576 (1 MB).
+* `MaxBytes`, which caps the total amount of evidence. The default is 1048576 (1 MB). 
 
 ### Crypto
 
@@ -203,7 +188,7 @@ blockchains, we recommend that you check the chain ID.
 
 ### Version
 
-Version is now set through Go linker flags `ld_flags`. Applications that are using tendermint as a library should set this at compile time.
+Version is now set through Go linker flags `ld_flags`. Applications that are using tendermint as a library should set this at compile time. 
 
 Example:
 
@@ -211,7 +196,7 @@ Example:
 go install -mod=readonly -ldflags "-X github.com/tendermint/tendermint/version.TMCoreSemVer=$(go list -m github.com/tendermint/tendermint | sed  's/ /\@/g') -s -w " -trimpath ./cmd
 ```
 
-Additionally, the exported constant `version.Version` is now `version.TMCoreSemVer`.
+Additionally, the exported constant `version.Version` is now `version.TMCoreSemVer`. 
 
 ## v0.33.4
 

abci/client/client.go

@@ -14,8 +14,6 @@ const (
 	echoRetryIntervalSeconds = 1
 )
 
-//go:generate mockery --case underscore --name Client
-
 // Client defines an interface for an ABCI client.
 // All `Async` methods return a `ReqRes` object.
 // All `Sync` methods return the appropriate protobuf ResponseXxx struct and an error.
@@ -36,14 +34,12 @@ type Client interface {
 	QueryAsync(types.RequestQuery) *ReqRes
 	CommitAsync() *ReqRes
 	InitChainAsync(types.RequestInitChain) *ReqRes
-	PrepareProposalAsync(types.RequestPrepareProposal) *ReqRes
 	BeginBlockAsync(types.RequestBeginBlock) *ReqRes
 	EndBlockAsync(types.RequestEndBlock) *ReqRes
 	ListSnapshotsAsync(types.RequestListSnapshots) *ReqRes
 	OfferSnapshotAsync(types.RequestOfferSnapshot) *ReqRes
 	LoadSnapshotChunkAsync(types.RequestLoadSnapshotChunk) *ReqRes
 	ApplySnapshotChunkAsync(types.RequestApplySnapshotChunk) *ReqRes
-	ProcessProposalAsync(types.RequestProcessProposal) *ReqRes
 
 	FlushSync() error
 	EchoSync(msg string) (*types.ResponseEcho, error)
@@ -54,14 +50,12 @@ type Client interface {
 	QuerySync(types.RequestQuery) (*types.ResponseQuery, error)
 	CommitSync() (*types.ResponseCommit, error)
 	InitChainSync(types.RequestInitChain) (*types.ResponseInitChain, error)
-	PrepareProposalSync(types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error)
 	BeginBlockSync(types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
 	EndBlockSync(types.RequestEndBlock) (*types.ResponseEndBlock, error)
 	ListSnapshotsSync(types.RequestListSnapshots) (*types.ResponseListSnapshots, error)
 	OfferSnapshotSync(types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)
 	LoadSnapshotChunkSync(types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)
 	ApplySnapshotChunkSync(types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error)
-	ProcessProposalSync(types.RequestProcessProposal) (*types.ResponseProcessProposal, error)
 }
 
 //----------------------------------------
@@ -87,15 +81,9 @@ type ReqRes struct {
 	*sync.WaitGroup
 	*types.Response // Not set atomically, so be sure to use WaitGroup.
 
-	mtx tmsync.Mutex
-
-	// callbackInvoked as a variable to track if the callback was already
-	// invoked during the regular execution of the request. This variable
-	// allows clients to set the callback simultaneously without potentially
-	// invoking the callback twice by accident, once when 'SetCallback' is
-	// called and once during the normal request.
-	callbackInvoked bool
-	cb              func(*types.Response) // A single callback that may be set.
+	mtx  tmsync.Mutex
+	done bool                  // Gets set to true once *after* WaitGroup.Done().
+	cb   func(*types.Response) // A single callback that may be set.
 }
 
 func NewReqRes(req *types.Request) *ReqRes {
@@ -104,8 +92,8 @@ func NewReqRes(req *types.Request) *ReqRes {
 		WaitGroup: waitGroup1(),
 		Response:  nil,
 
-		callbackInvoked: false,
-		cb:              nil,
+		done: false,
+		cb:   nil,
 	}
 }
 
@@ -115,7 +103,7 @@ func NewReqRes(req *types.Request) *ReqRes {
 func (r *ReqRes) SetCallback(cb func(res *types.Response)) {
 	r.mtx.Lock()
 
-	if r.callbackInvoked {
+	if r.done {
 		r.mtx.Unlock()
 		cb(r.Response)
 		return
@@ -134,7 +122,6 @@ func (r *ReqRes) InvokeCallback() {
 	if r.cb != nil {
 		r.cb(r.Response)
 	}
-	r.callbackInvoked = true
 }
 
 // GetCallback returns the configured callback of the ReqRes object which may be
@@ -149,6 +136,13 @@ func (r *ReqRes) GetCallback() func(*types.Response) {
 	return r.cb
 }
 
+// SetDone marks the ReqRes object as done.
+func (r *ReqRes) SetDone() {
+	r.mtx.Lock()
+	r.done = true
+	r.mtx.Unlock()
+}
+
 func waitGroup1() (wg *sync.WaitGroup) {
 	wg = &sync.WaitGroup{}
 	wg.Add(1)

abci/client/grpc_client.go

@@ -66,6 +66,7 @@ func (cli *grpcClient) OnStart() error {
 			cli.mtx.Lock()
 			defer cli.mtx.Unlock()
 
+			reqres.SetDone()
 			reqres.Done()
 
 			// Notify client listener if set
@@ -74,7 +75,9 @@ func (cli *grpcClient) OnStart() error {
 			}
 
 			// Notify reqRes listener if set
-			reqres.InvokeCallback()
+			if cb := reqres.GetCallback(); cb != nil {
+				cb(reqres.Response)
+			}
 		}
 		for reqres := range cli.chReqRes {
 			if reqres != nil {
@@ -87,7 +90,6 @@ func (cli *grpcClient) OnStart() error {
 
 RETRY_LOOP:
 	for {
-		//nolint:staticcheck // SA1019 Existing use of deprecated but supported dial option.
 		conn, err := grpc.Dial(cli.addr, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
 		if err != nil {
 			if cli.mustConnect {
@@ -300,25 +302,6 @@ func (cli *grpcClient) ApplySnapshotChunkAsync(params types.RequestApplySnapshot
 	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ApplySnapshotChunk{ApplySnapshotChunk: res}})
 }
 
-func (cli *grpcClient) PrepareProposalAsync(params types.RequestPrepareProposal) *ReqRes {
-	req := types.ToRequestPrepareProposal(params)
-	res, err := cli.client.PrepareProposal(context.Background(), req.GetPrepareProposal(), grpc.WaitForReady(true))
-	if err != nil {
-		cli.StopForError(err)
-	}
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_PrepareProposal{PrepareProposal: res}})
-}
-
-func (cli *grpcClient) ProcessProposalAsync(params types.RequestProcessProposal) *ReqRes {
-	req := types.ToRequestProcessProposal(params)
-	res, err := cli.client.ProcessProposal(context.Background(), req.GetProcessProposal(), grpc.WaitForReady(true))
-	if err != nil {
-		cli.StopForError(err)
-	}
-
-	return cli.finishAsyncCall(req, &types.Response{Value: &types.Response_ProcessProposal{ProcessProposal: res}})
-}
-
 // finishAsyncCall creates a ReqRes for an async call, and immediately populates it
 // with the response. We don't complete it until it's been ordered via the channel.
 func (cli *grpcClient) finishAsyncCall(req *types.Request, res *types.Response) *ReqRes {
@@ -359,9 +342,7 @@ func (cli *grpcClient) finishSyncCall(reqres *ReqRes) *types.Response {
 //----------------------------------------
 
 func (cli *grpcClient) FlushSync() error {
-	reqres := cli.FlushAsync()
-	cli.finishSyncCall(reqres).GetFlush()
-	return cli.Error()
+	return nil
 }
 
 func (cli *grpcClient) EchoSync(msg string) (*types.ResponseEcho, error) {
@@ -436,14 +417,3 @@ func (cli *grpcClient) ApplySnapshotChunkSync(
 	reqres := cli.ApplySnapshotChunkAsync(params)
 	return cli.finishSyncCall(reqres).GetApplySnapshotChunk(), cli.Error()
 }
-
-func (cli *grpcClient) PrepareProposalSync(
-	params types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	reqres := cli.PrepareProposalAsync(params)
-	return cli.finishSyncCall(reqres).GetPrepareProposal(), cli.Error()
-}
-
-func (cli *grpcClient) ProcessProposalSync(params types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	reqres := cli.ProcessProposalAsync(params)
-	return cli.finishSyncCall(reqres).GetProcessProposal(), cli.Error()
-}

abci/client/local_client.go

@@ -207,28 +207,6 @@ func (app *localClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotCh
 	)
 }
 
-func (app *localClient) PrepareProposalAsync(req types.RequestPrepareProposal) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.PrepareProposal(req)
-	return app.callback(
-		types.ToRequestPrepareProposal(req),
-		types.ToResponsePrepareProposal(res),
-	)
-}
-
-func (app *localClient) ProcessProposalAsync(req types.RequestProcessProposal) *ReqRes {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.ProcessProposal(req)
-	return app.callback(
-		types.ToRequestProcessProposal(req),
-		types.ToResponseProcessProposal(res),
-	)
-}
-
 //-------------------------------------------------------
 
 func (app *localClient) FlushSync() error {
@@ -345,33 +323,16 @@ func (app *localClient) ApplySnapshotChunkSync(
 	return &res, nil
 }
 
-func (app *localClient) PrepareProposalSync(req types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.PrepareProposal(req)
-	return &res, nil
-}
-
-func (app *localClient) ProcessProposalSync(req types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.ProcessProposal(req)
-	return &res, nil
-}
-
 //-------------------------------------------------------
 
 func (app *localClient) callback(req *types.Request, res *types.Response) *ReqRes {
 	app.Callback(req, res)
-	rr := newLocalReqRes(req, res)
-	rr.callbackInvoked = true
-	return rr
+	return newLocalReqRes(req, res)
 }
 
 func newLocalReqRes(req *types.Request, res *types.Response) *ReqRes {
 	reqRes := NewReqRes(req)
 	reqRes.Response = res
+	reqRes.SetDone()
 	return reqRes
 }

abci/client/mocks/client.go

@@ -1,4 +1,4 @@
-// Code generated by mockery v2.14.0. DO NOT EDIT.
+// Code generated by mockery v1.1.1. DO NOT EDIT.
 
 package mocks
 
@@ -575,84 +575,6 @@ func (_m *Client) OnStop() {
 	_m.Called()
 }
 
-// PrepareProposalAsync provides a mock function with given fields: _a0
-func (_m *Client) PrepareProposalAsync(_a0 types.RequestPrepareProposal) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
-
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abcicli.ReqRes)
-		}
-	}
-
-	return r0
-}
-
-// PrepareProposalSync provides a mock function with given fields: _a0
-func (_m *Client) PrepareProposalSync(_a0 types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *types.ResponsePrepareProposal
-	if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) *types.ResponsePrepareProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponsePrepareProposal)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestPrepareProposal) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// ProcessProposalAsync provides a mock function with given fields: _a0
-func (_m *Client) ProcessProposalAsync(_a0 types.RequestProcessProposal) *abcicli.ReqRes {
-	ret := _m.Called(_a0)
-
-	var r0 *abcicli.ReqRes
-	if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) *abcicli.ReqRes); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abcicli.ReqRes)
-		}
-	}
-
-	return r0
-}
-
-// ProcessProposalSync provides a mock function with given fields: _a0
-func (_m *Client) ProcessProposalSync(_a0 types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	ret := _m.Called(_a0)
-
-	var r0 *types.ResponseProcessProposal
-	if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) *types.ResponseProcessProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseProcessProposal)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(types.RequestProcessProposal) error); ok {
-		r1 = rf(_a0)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
 // QueryAsync provides a mock function with given fields: _a0
 func (_m *Client) QueryAsync(_a0 types.RequestQuery) *abcicli.ReqRes {
 	ret := _m.Called(_a0)
@@ -812,18 +734,3 @@ func (_m *Client) String() string {
 
 	return r0
 }
-
-type mockConstructorTestingTNewClient interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewClient(t mockConstructorTestingTNewClient) *Client {
-	mock := &Client{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

abci/client/socket_client.go

@@ -279,14 +279,6 @@ func (cli *socketClient) ApplySnapshotChunkAsync(req types.RequestApplySnapshotC
 	return cli.queueRequest(types.ToRequestApplySnapshotChunk(req))
 }
 
-func (cli *socketClient) PrepareProposalAsync(req types.RequestPrepareProposal) *ReqRes {
-	return cli.queueRequest(types.ToRequestPrepareProposal(req))
-}
-
-func (cli *socketClient) ProcessProposalAsync(req types.RequestProcessProposal) *ReqRes {
-	return cli.queueRequest(types.ToRequestProcessProposal(req))
-}
-
 //----------------------------------------
 
 func (cli *socketClient) FlushSync() error {
@@ -425,24 +417,6 @@ func (cli *socketClient) ApplySnapshotChunkSync(
 	return reqres.Response.GetApplySnapshotChunk(), cli.Error()
 }
 
-func (cli *socketClient) PrepareProposalSync(req types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	reqres := cli.queueRequest(types.ToRequestPrepareProposal(req))
-	if err := cli.FlushSync(); err != nil {
-		return nil, err
-	}
-
-	return reqres.Response.GetPrepareProposal(), cli.Error()
-}
-
-func (cli *socketClient) ProcessProposalSync(req types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	reqres := cli.queueRequest(types.ToRequestProcessProposal(req))
-	if err := cli.FlushSync(); err != nil {
-		return nil, err
-	}
-
-	return reqres.Response.GetProcessProposal(), cli.Error()
-}
-
 //----------------------------------------
 
 func (cli *socketClient) queueRequest(req *types.Request) *ReqRes {
@@ -518,10 +492,6 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_ListSnapshots)
 	case *types.Request_OfferSnapshot:
 		_, ok = res.Value.(*types.Response_OfferSnapshot)
-	case *types.Request_PrepareProposal:
-		_, ok = res.Value.(*types.Response_PrepareProposal)
-	case *types.Request_ProcessProposal:
-		_, ok = res.Value.(*types.Response_ProcessProposal)
 	}
 	return ok
 }

abci/client/socket_client_test.go

@@ -2,7 +2,6 @@ package abcicli_test
 
 import (
 	"fmt"
-	"sync"
 	"testing"
 	"time"
 
@@ -119,71 +118,3 @@ func (slowApp) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock
 	time.Sleep(200 * time.Millisecond)
 	return types.ResponseBeginBlock{}
 }
-
-// TestCallbackInvokedWhenSetLaet ensures that the callback is invoked when
-// set after the client completes the call into the app. Currently this
-// test relies on the callback being allowed to be invoked twice if set multiple
-// times, once when set early and once when set late.
-func TestCallbackInvokedWhenSetLate(t *testing.T) {
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-	app := blockedABCIApplication{
-		wg: wg,
-	}
-	_, c := setupClientServer(t, app)
-	reqRes := c.CheckTxAsync(types.RequestCheckTx{})
-
-	done := make(chan struct{})
-	cb := func(_ *types.Response) {
-		close(done)
-	}
-	reqRes.SetCallback(cb)
-	app.wg.Done()
-	<-done
-
-	var called bool
-	cb = func(_ *types.Response) {
-		called = true
-	}
-	reqRes.SetCallback(cb)
-	require.True(t, called)
-}
-
-type blockedABCIApplication struct {
-	wg *sync.WaitGroup
-	types.BaseApplication
-}
-
-func (b blockedABCIApplication) CheckTx(r types.RequestCheckTx) types.ResponseCheckTx {
-	b.wg.Wait()
-	return b.BaseApplication.CheckTx(r)
-}
-
-// TestCallbackInvokedWhenSetEarly ensures that the callback is invoked when
-// set before the client completes the call into the app.
-func TestCallbackInvokedWhenSetEarly(t *testing.T) {
-	wg := &sync.WaitGroup{}
-	wg.Add(1)
-	app := blockedABCIApplication{
-		wg: wg,
-	}
-	_, c := setupClientServer(t, app)
-	reqRes := c.CheckTxAsync(types.RequestCheckTx{})
-
-	done := make(chan struct{})
-	cb := func(_ *types.Response) {
-		close(done)
-	}
-	reqRes.SetCallback(cb)
-	app.wg.Done()
-
-	called := func() bool {
-		select {
-		case <-done:
-			return true
-		default:
-			return false
-		}
-	}
-	require.Eventually(t, called, time.Second, time.Millisecond*25)
-}

abci/example/example_test.go

@@ -130,7 +130,7 @@ func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
 
 func testGRPCSync(t *testing.T, app types.ABCIApplicationServer) {
 	numDeliverTxs := 2000
-	socketFile := fmt.Sprintf("/tmp/test-%08x.sock", rand.Int31n(1<<30))
+	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
 	defer os.Remove(socketFile)
 	socket := fmt.Sprintf("unix://%v", socketFile)
 
@@ -148,7 +148,6 @@ func testGRPCSync(t *testing.T, app types.ABCIApplicationServer) {
 	})
 
 	// Connect to the socket
-	//nolint:staticcheck // SA1019 Existing use of deprecated but supported dial option.
 	conn, err := grpc.Dial(socket, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
 	if err != nil {
 		t.Fatalf("Error dialing GRPC server: %v", err.Error())

abci/example/kvstore/kvstore.go

@@ -170,13 +170,3 @@ func (app *Application) Query(reqQuery types.RequestQuery) (resQuery types.Respo
 
 	return resQuery
 }
-
-func (app *Application) ProcessProposal(
-	req types.RequestProcessProposal) types.ResponseProcessProposal {
-	for _, tx := range req.Txs {
-		if len(tx) == 0 {
-			return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}
-		}
-	}
-	return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_ACCEPT}
-}

abci/example/kvstore/kvstore_test.go

@@ -293,7 +293,7 @@ func TestClientServer(t *testing.T) {
 
 	// set up grpc app
 	kvstore = NewApplication()
-	gclient, gserver, err := makeGRPCClientServer(kvstore, "/tmp/kvstore-grpc")
+	gclient, gserver, err := makeGRPCClientServer(kvstore, "kvstore-grpc")
 	require.NoError(t, err)
 
 	t.Cleanup(func() {

abci/example/kvstore/persistent_kvstore.go

@@ -76,10 +76,6 @@ func (app *PersistentKVStoreApplication) DeliverTx(req types.RequestDeliverTx) t
 		return app.execValidatorTx(req.Tx)
 	}
 
-	if isPrepareTx(req.Tx) {
-		return app.execPrepareTx(req.Tx)
-	}
-
 	// otherwise, update the key-value store
 	return app.app.DeliverTx(req)
 }
@@ -174,21 +170,6 @@ func (app *PersistentKVStoreApplication) ApplySnapshotChunk(
 	return types.ResponseApplySnapshotChunk{Result: types.ResponseApplySnapshotChunk_ABORT}
 }
 
-func (app *PersistentKVStoreApplication) PrepareProposal(
-	req types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	return types.ResponsePrepareProposal{TxRecords: app.substPrepareTx(req.Txs, req.MaxTxBytes)}
-}
-
-func (app *PersistentKVStoreApplication) ProcessProposal(
-	req types.RequestProcessProposal) types.ResponseProcessProposal {
-	for _, tx := range req.Txs {
-		if len(tx) == 0 {
-			return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_REJECT}
-		}
-	}
-	return types.ResponseProcessProposal{Status: types.ResponseProcessProposal_ACCEPT}
-}
-
 //---------------------------------------------
 // update validators
 
@@ -303,50 +284,3 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate
 
 	return types.ResponseDeliverTx{Code: code.CodeTypeOK}
 }
-
-// -----------------------------
-
-const PreparePrefix = "prepare"
-
-func isPrepareTx(tx []byte) bool {
-	return bytes.HasPrefix(tx, []byte(PreparePrefix))
-}
-
-// execPrepareTx is noop. tx data is considered as placeholder
-// and is substitute at the PrepareProposal.
-func (app *PersistentKVStoreApplication) execPrepareTx(tx []byte) types.ResponseDeliverTx {
-	// noop
-	return types.ResponseDeliverTx{}
-}
-
-// substPrepareTx substitutes all the transactions prefixed with 'prepare' in the
-// proposal for transactions with the prefix stripped.
-// It marks all of the original transactions as 'REMOVED' so that
-// Tendermint will remove them from its mempool.
-func (app *PersistentKVStoreApplication) substPrepareTx(blockData [][]byte, maxTxBytes int64) []*types.TxRecord {
-	trs := make([]*types.TxRecord, 0, len(blockData))
-	var removed []*types.TxRecord
-	var totalBytes int64
-	for _, tx := range blockData {
-		txMod := tx
-		action := types.TxRecord_UNMODIFIED
-		if isPrepareTx(tx) {
-			removed = append(removed, &types.TxRecord{
-				Tx:     tx,
-				Action: types.TxRecord_REMOVED,
-			})
-			txMod = bytes.TrimPrefix(tx, []byte(PreparePrefix))
-			action = types.TxRecord_ADDED
-		}
-		totalBytes += int64(len(txMod))
-		if totalBytes > maxTxBytes {
-			break
-		}
-		trs = append(trs, &types.TxRecord{
-			Tx:     txMod,
-			Action: action,
-		})
-	}
-
-	return append(trs, removed...)
-}

abci/server/socket_server.go

@@ -230,12 +230,6 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_OfferSnapshot:
 		res := s.app.OfferSnapshot(*r.OfferSnapshot)
 		responses <- types.ToResponseOfferSnapshot(res)
-	case *types.Request_PrepareProposal:
-		res := s.app.PrepareProposal(*r.PrepareProposal)
-		responses <- types.ToResponsePrepareProposal(res)
-	case *types.Request_ProcessProposal:
-		res := s.app.ProcessProposal(*r.ProcessProposal)
-		responses <- types.ToResponseProcessProposal(res)
 	case *types.Request_LoadSnapshotChunk:
 		res := s.app.LoadSnapshotChunk(*r.LoadSnapshotChunk)
 		responses <- types.ToResponseLoadSnapshotChunk(res)

abci/types/application.go

@@ -4,8 +4,6 @@ import (
 	context "golang.org/x/net/context"
 )
 
-//go:generate ../../scripts/mockery_generate.sh Application
-
 // Application is an interface that enables any finite, deterministic state machine
 // to be driven by a blockchain-based replication engine via the ABCI.
 // All methods take a RequestXxx argument and return a ResponseXxx argument,
@@ -20,9 +18,7 @@ type Application interface {
 	CheckTx(RequestCheckTx) ResponseCheckTx // Validate a tx for the mempool
 
 	// Consensus Connection
-	InitChain(RequestInitChain) ResponseInitChain // Initialize blockchain w validators/other info from TendermintCore
-	PrepareProposal(RequestPrepareProposal) ResponsePrepareProposal
-	ProcessProposal(RequestProcessProposal) ResponseProcessProposal
+	InitChain(RequestInitChain) ResponseInitChain    // Initialize blockchain w validators/other info from TendermintCore
 	BeginBlock(RequestBeginBlock) ResponseBeginBlock // Signals the beginning of a block
 	DeliverTx(RequestDeliverTx) ResponseDeliverTx    // Deliver a tx for full processing
 	EndBlock(RequestEndBlock) ResponseEndBlock       // Signals the end of a block, returns changes to the validator set
@@ -99,27 +95,6 @@ func (BaseApplication) ApplySnapshotChunk(req RequestApplySnapshotChunk) Respons
 	return ResponseApplySnapshotChunk{}
 }
 
-func (BaseApplication) PrepareProposal(req RequestPrepareProposal) ResponsePrepareProposal {
-	trs := make([]*TxRecord, 0, len(req.Txs))
-	var totalBytes int64
-	for _, tx := range req.Txs {
-		totalBytes += int64(len(tx))
-		if totalBytes > req.MaxTxBytes {
-			break
-		}
-		trs = append(trs, &TxRecord{
-			Action: TxRecord_UNMODIFIED,
-			Tx:     tx,
-		})
-	}
-	return ResponsePrepareProposal{TxRecords: trs}
-}
-
-func (BaseApplication) ProcessProposal(req RequestProcessProposal) ResponseProcessProposal {
-	return ResponseProcessProposal{
-		Status: ResponseProcessProposal_ACCEPT}
-}
-
 //-------------------------------------------------------
 
 // GRPCApplication is a GRPC wrapper for Application
@@ -207,15 +182,3 @@ func (app *GRPCApplication) ApplySnapshotChunk(
 	res := app.app.ApplySnapshotChunk(*req)
 	return &res, nil
 }
-
-func (app *GRPCApplication) PrepareProposal(
-	ctx context.Context, req *RequestPrepareProposal) (*ResponsePrepareProposal, error) {
-	res := app.app.PrepareProposal(*req)
-	return &res, nil
-}
-
-func (app *GRPCApplication) ProcessProposal(
-	ctx context.Context, req *RequestProcessProposal) (*ResponseProcessProposal, error) {
-	res := app.app.ProcessProposal(*req)
-	return &res, nil
-}

abci/types/messages.go

@@ -159,18 +159,6 @@ func ToRequestApplySnapshotChunk(req RequestApplySnapshotChunk) *Request {
 	}
 }
 
-func ToRequestPrepareProposal(req RequestPrepareProposal) *Request {
-	return &Request{
-		Value: &Request_PrepareProposal{&req},
-	}
-}
-
-func ToRequestProcessProposal(req RequestProcessProposal) *Request {
-	return &Request{
-		Value: &Request_ProcessProposal{&req},
-	}
-}
-
 //----------------------------------------
 
 func ToResponseException(errStr string) *Response {
@@ -268,15 +256,3 @@ func ToResponseApplySnapshotChunk(res ResponseApplySnapshotChunk) *Response {
 		Value: &Response_ApplySnapshotChunk{&res},
 	}
 }
-
-func ToResponsePrepareProposal(res ResponsePrepareProposal) *Response {
-	return &Response{
-		Value: &Response_PrepareProposal{&res},
-	}
-}
-
-func ToResponseProcessProposal(res ResponseProcessProposal) *Response {
-	return &Response{
-		Value: &Response_ProcessProposal{&res},
-	}
-}

abci/types/mocks/application.go

@@ -1,238 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	mock "github.com/stretchr/testify/mock"
-	types "github.com/tendermint/tendermint/abci/types"
-)
-
-// Application is an autogenerated mock type for the Application type
-type Application struct {
-	mock.Mock
-}
-
-// ApplySnapshotChunk provides a mock function with given fields: _a0
-func (_m *Application) ApplySnapshotChunk(_a0 types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseApplySnapshotChunk
-	if rf, ok := ret.Get(0).(func(types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseApplySnapshotChunk)
-	}
-
-	return r0
-}
-
-// BeginBlock provides a mock function with given fields: _a0
-func (_m *Application) BeginBlock(_a0 types.RequestBeginBlock) types.ResponseBeginBlock {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseBeginBlock
-	if rf, ok := ret.Get(0).(func(types.RequestBeginBlock) types.ResponseBeginBlock); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseBeginBlock)
-	}
-
-	return r0
-}
-
-// CheckTx provides a mock function with given fields: _a0
-func (_m *Application) CheckTx(_a0 types.RequestCheckTx) types.ResponseCheckTx {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseCheckTx
-	if rf, ok := ret.Get(0).(func(types.RequestCheckTx) types.ResponseCheckTx); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseCheckTx)
-	}
-
-	return r0
-}
-
-// Commit provides a mock function with given fields:
-func (_m *Application) Commit() types.ResponseCommit {
-	ret := _m.Called()
-
-	var r0 types.ResponseCommit
-	if rf, ok := ret.Get(0).(func() types.ResponseCommit); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(types.ResponseCommit)
-	}
-
-	return r0
-}
-
-// DeliverTx provides a mock function with given fields: _a0
-func (_m *Application) DeliverTx(_a0 types.RequestDeliverTx) types.ResponseDeliverTx {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseDeliverTx
-	if rf, ok := ret.Get(0).(func(types.RequestDeliverTx) types.ResponseDeliverTx); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseDeliverTx)
-	}
-
-	return r0
-}
-
-// EndBlock provides a mock function with given fields: _a0
-func (_m *Application) EndBlock(_a0 types.RequestEndBlock) types.ResponseEndBlock {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseEndBlock
-	if rf, ok := ret.Get(0).(func(types.RequestEndBlock) types.ResponseEndBlock); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseEndBlock)
-	}
-
-	return r0
-}
-
-// Info provides a mock function with given fields: _a0
-func (_m *Application) Info(_a0 types.RequestInfo) types.ResponseInfo {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseInfo
-	if rf, ok := ret.Get(0).(func(types.RequestInfo) types.ResponseInfo); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseInfo)
-	}
-
-	return r0
-}
-
-// InitChain provides a mock function with given fields: _a0
-func (_m *Application) InitChain(_a0 types.RequestInitChain) types.ResponseInitChain {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseInitChain
-	if rf, ok := ret.Get(0).(func(types.RequestInitChain) types.ResponseInitChain); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseInitChain)
-	}
-
-	return r0
-}
-
-// ListSnapshots provides a mock function with given fields: _a0
-func (_m *Application) ListSnapshots(_a0 types.RequestListSnapshots) types.ResponseListSnapshots {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseListSnapshots
-	if rf, ok := ret.Get(0).(func(types.RequestListSnapshots) types.ResponseListSnapshots); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseListSnapshots)
-	}
-
-	return r0
-}
-
-// LoadSnapshotChunk provides a mock function with given fields: _a0
-func (_m *Application) LoadSnapshotChunk(_a0 types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseLoadSnapshotChunk
-	if rf, ok := ret.Get(0).(func(types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseLoadSnapshotChunk)
-	}
-
-	return r0
-}
-
-// OfferSnapshot provides a mock function with given fields: _a0
-func (_m *Application) OfferSnapshot(_a0 types.RequestOfferSnapshot) types.ResponseOfferSnapshot {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseOfferSnapshot
-	if rf, ok := ret.Get(0).(func(types.RequestOfferSnapshot) types.ResponseOfferSnapshot); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseOfferSnapshot)
-	}
-
-	return r0
-}
-
-// PrepareProposal provides a mock function with given fields: _a0
-func (_m *Application) PrepareProposal(_a0 types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponsePrepareProposal
-	if rf, ok := ret.Get(0).(func(types.RequestPrepareProposal) types.ResponsePrepareProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponsePrepareProposal)
-	}
-
-	return r0
-}
-
-// ProcessProposal provides a mock function with given fields: _a0
-func (_m *Application) ProcessProposal(_a0 types.RequestProcessProposal) types.ResponseProcessProposal {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseProcessProposal
-	if rf, ok := ret.Get(0).(func(types.RequestProcessProposal) types.ResponseProcessProposal); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseProcessProposal)
-	}
-
-	return r0
-}
-
-// Query provides a mock function with given fields: _a0
-func (_m *Application) Query(_a0 types.RequestQuery) types.ResponseQuery {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseQuery
-	if rf, ok := ret.Get(0).(func(types.RequestQuery) types.ResponseQuery); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseQuery)
-	}
-
-	return r0
-}
-
-// SetOption provides a mock function with given fields: _a0
-func (_m *Application) SetOption(_a0 types.RequestSetOption) types.ResponseSetOption {
-	ret := _m.Called(_a0)
-
-	var r0 types.ResponseSetOption
-	if rf, ok := ret.Get(0).(func(types.RequestSetOption) types.ResponseSetOption); ok {
-		r0 = rf(_a0)
-	} else {
-		r0 = ret.Get(0).(types.ResponseSetOption)
-	}
-
-	return r0
-}
-
-type mockConstructorTestingTNewApplication interface {
-	mock.TestingT
-	Cleanup(func())
-}
-
-// NewApplication creates a new instance of Application. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
-func NewApplication(t mockConstructorTestingTNewApplication) *Application {
-	mock := &Application{}
-	mock.Mock.Test(t)
-
-	t.Cleanup(func() { mock.AssertExpectations(t) })
-
-	return mock
-}

abci/types/mocks/base.go

@@ -1,187 +0,0 @@
-package mocks
-
-import (
-	types "github.com/tendermint/tendermint/abci/types"
-)
-
-// BaseMock provides a wrapper around the generated Application mock and a BaseApplication.
-// BaseMock first tries to use the mock's implementation of the method.
-// If no functionality was provided for the mock by the user, BaseMock dispatches
-// to the BaseApplication and uses its functionality.
-// BaseMock allows users to provide mocked functionality for only the methods that matter
-// for their test while avoiding a panic if the code calls Application methods that are
-// not relevant to the test.
-type BaseMock struct {
-	base *types.BaseApplication
-	*Application
-}
-
-func NewBaseMock() BaseMock {
-	return BaseMock{
-		base:        types.NewBaseApplication(),
-		Application: new(Application),
-	}
-}
-
-// Info/Query Connection
-// Return application info
-func (m BaseMock) Info(input types.RequestInfo) types.ResponseInfo {
-	var ret types.ResponseInfo
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.Info(input)
-		}
-	}()
-	ret = m.Application.Info(input)
-	return ret
-}
-
-func (m BaseMock) Query(input types.RequestQuery) types.ResponseQuery {
-	var ret types.ResponseQuery
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.Query(input)
-		}
-	}()
-	ret = m.Application.Query(input)
-	return ret
-}
-
-// Mempool Connection
-// Validate a tx for the mempool
-func (m BaseMock) CheckTx(input types.RequestCheckTx) types.ResponseCheckTx {
-	var ret types.ResponseCheckTx
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.CheckTx(input)
-		}
-	}()
-	ret = m.Application.CheckTx(input)
-	return ret
-}
-
-// Consensus Connection
-// Initialize blockchain w validators/other info from TendermintCore
-func (m BaseMock) InitChain(input types.RequestInitChain) types.ResponseInitChain {
-	var ret types.ResponseInitChain
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.InitChain(input)
-		}
-	}()
-	ret = m.Application.InitChain(input)
-	return ret
-}
-
-func (m BaseMock) PrepareProposal(input types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	var ret types.ResponsePrepareProposal
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.PrepareProposal(input)
-		}
-	}()
-	ret = m.Application.PrepareProposal(input)
-	return ret
-}
-
-func (m BaseMock) ProcessProposal(input types.RequestProcessProposal) types.ResponseProcessProposal {
-	var ret types.ResponseProcessProposal
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.ProcessProposal(input)
-		}
-	}()
-	ret = m.Application.ProcessProposal(input)
-	return ret
-}
-
-// Commit the state and return the application Merkle root hash
-func (m BaseMock) Commit() types.ResponseCommit {
-	var ret types.ResponseCommit
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.Commit()
-		}
-	}()
-	ret = m.Application.Commit()
-	return ret
-}
-
-// State Sync Connection
-// List available snapshots
-func (m BaseMock) ListSnapshots(input types.RequestListSnapshots) types.ResponseListSnapshots {
-	var ret types.ResponseListSnapshots
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.ListSnapshots(input)
-		}
-	}()
-	ret = m.Application.ListSnapshots(input)
-	return ret
-}
-
-func (m BaseMock) OfferSnapshot(input types.RequestOfferSnapshot) types.ResponseOfferSnapshot {
-	var ret types.ResponseOfferSnapshot
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.OfferSnapshot(input)
-		}
-	}()
-	ret = m.Application.OfferSnapshot(input)
-	return ret
-}
-
-func (m BaseMock) LoadSnapshotChunk(input types.RequestLoadSnapshotChunk) types.ResponseLoadSnapshotChunk {
-	var ret types.ResponseLoadSnapshotChunk
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.LoadSnapshotChunk(input)
-		}
-	}()
-	ret = m.Application.LoadSnapshotChunk(input)
-	return ret
-}
-
-func (m BaseMock) ApplySnapshotChunk(input types.RequestApplySnapshotChunk) types.ResponseApplySnapshotChunk {
-	var ret types.ResponseApplySnapshotChunk
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.ApplySnapshotChunk(input)
-		}
-	}()
-	ret = m.Application.ApplySnapshotChunk(input)
-	return ret
-}
-
-func (m BaseMock) BeginBlock(input types.RequestBeginBlock) types.ResponseBeginBlock {
-	var ret types.ResponseBeginBlock
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.BeginBlock(input)
-		}
-	}()
-	ret = m.Application.BeginBlock(input)
-	return ret
-}
-
-func (m BaseMock) DeliverTx(input types.RequestDeliverTx) types.ResponseDeliverTx {
-	var ret types.ResponseDeliverTx
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.DeliverTx(input)
-		}
-	}()
-	ret = m.Application.DeliverTx(input)
-	return ret
-}
-
-func (m BaseMock) EndBlock(input types.RequestEndBlock) types.ResponseEndBlock {
-	var ret types.ResponseEndBlock
-	defer func() {
-		if r := recover(); r != nil {
-			ret = m.base.EndBlock(input)
-		}
-	}()
-	ret = m.Application.EndBlock(input)
-	return ret
-}

abci/types/result.go

@@ -41,18 +41,8 @@ func (r ResponseQuery) IsErr() bool {
 	return r.Code != CodeTypeOK
 }
 
-// IsAccepted returns true if Code is ACCEPT
-func (r ResponseProcessProposal) IsAccepted() bool {
-	return r.Status == ResponseProcessProposal_ACCEPT
-}
-
-// IsStatusUnknown returns true if Code is UNKNOWN
-func (r ResponseProcessProposal) IsStatusUnknown() bool {
-	return r.Status == ResponseProcessProposal_UNKNOWN
-}
-
 //---------------------------------------------------------------------------
-// override JSON marshaling so we emit defaults (ie. disable omitempty)
+// override JSON marshalling so we emit defaults (ie. disable omitempty)
 
 var (
 	jsonpbMarshaller = jsonpb.Marshaler{

appveyor.yml

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

behaviour/doc.go

@@ -1,10 +1,10 @@
 /*
-Package Behavior provides a mechanism for reactors to report behavior of peers.
+Package Behaviour provides a mechanism for reactors to report behaviour of peers.
 
-Instead of a reactor calling the switch directly it will call the behavior module which will
+Instead of a reactor calling the switch directly it will call the behaviour 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.
+There are four different behaviours a reactor can report.
 
 1. bad message
 
@@ -39,4 +39,4 @@ type blockPart struct {
 This message will request the peer be marked as good
 
 */
-package behaviour //nolint:misspell
+package behaviour

behaviour/peer_behaviour.go

@@ -1,12 +1,12 @@
-package behaviour //nolint:misspell
+package behaviour
 
 import (
 	"github.com/tendermint/tendermint/p2p"
 )
 
-// PeerBehaviour is a struct describing a behavior a peer performed.
+// PeerBehaviour is a struct describing a behaviour a peer performed.
 // `peerID` identifies the peer and reason characterizes the specific
-// behavior performed by the peer.
+// behaviour performed by the peer.
 type PeerBehaviour struct {
 	peerID p2p.ID
 	reason interface{}

behaviour/reporter.go

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

behaviour/reporter_test.go

@@ -1,41 +1,41 @@
-package behaviour_test //nolint:misspell
+package behaviour_test
 
 import (
 	"sync"
 	"testing"
 
-	bh "github.com/tendermint/tendermint/behaviour" //nolint:misspell
+	bh "github.com/tendermint/tendermint/behaviour"
 	"github.com/tendermint/tendermint/p2p"
 )
 
 // TestMockReporter tests the MockReporter's ability to store reported
-// peer behavior in memory indexed by the peerID.
+// peer behaviour in memory indexed by the peerID.
 func TestMockReporter(t *testing.T) {
 	var peerID p2p.ID = "MockPeer"
 	pr := bh.NewMockReporter()
 
-	behaviors := pr.GetBehaviours(peerID)
-	if len(behaviors) != 0 {
-		t.Error("Expected to have no behaviors reported")
+	behaviours := pr.GetBehaviours(peerID)
+	if len(behaviours) != 0 {
+		t.Error("Expected to have no behaviours reported")
 	}
 
 	badMessage := bh.BadMessage(peerID, "bad message")
 	if err := pr.Report(badMessage); err != nil {
 		t.Error(err)
 	}
-	behaviors = pr.GetBehaviours(peerID)
-	if len(behaviors) != 1 {
-		t.Error("Expected the peer have one reported behavior")
+	behaviours = pr.GetBehaviours(peerID)
+	if len(behaviours) != 1 {
+		t.Error("Expected the peer have one reported behaviour")
 	}
 
-	if behaviors[0] != badMessage {
+	if behaviours[0] != badMessage {
 		t.Error("Expected Bad Message to have been reported")
 	}
 }
 
 type scriptItem struct {
-	peerID   p2p.ID
-	behavior bh.PeerBehaviour
+	peerID    p2p.ID
+	behaviour bh.PeerBehaviour
 }
 
 // equalBehaviours returns true if a and b contain the same PeerBehaviours with
@@ -44,26 +44,26 @@ func equalBehaviours(a []bh.PeerBehaviour, b []bh.PeerBehaviour) bool {
 	aHistogram := map[bh.PeerBehaviour]int{}
 	bHistogram := map[bh.PeerBehaviour]int{}
 
-	for _, behavior := range a {
-		aHistogram[behavior]++
+	for _, behaviour := range a {
+		aHistogram[behaviour]++
 	}
 
-	for _, behavior := range b {
-		bHistogram[behavior]++
+	for _, behaviour := range b {
+		bHistogram[behaviour]++
 	}
 
 	if len(aHistogram) != len(bHistogram) {
 		return false
 	}
 
-	for _, behavior := range a {
-		if aHistogram[behavior] != bHistogram[behavior] {
+	for _, behaviour := range a {
+		if aHistogram[behaviour] != bHistogram[behaviour] {
 			return false
 		}
 	}
 
-	for _, behavior := range b {
-		if bHistogram[behavior] != aHistogram[behavior] {
+	for _, behaviour := range b {
+		if bHistogram[behaviour] != aHistogram[behaviour] {
 			return false
 		}
 	}
@@ -72,8 +72,8 @@ func equalBehaviours(a []bh.PeerBehaviour, b []bh.PeerBehaviour) bool {
 }
 
 // TestEqualPeerBehaviours tests that equalBehaviours can tell that two slices
-// of peer behaviors can be compared for the behaviors they contain and the
-// freequencies that those behaviors occur.
+// of peer behaviours can be compared for the behaviours they contain and the
+// freequencies that those behaviours occur.
 func TestEqualPeerBehaviours(t *testing.T) {
 	var (
 		peerID        p2p.ID = "MockPeer"
@@ -85,7 +85,7 @@ func TestEqualPeerBehaviours(t *testing.T) {
 		}{
 			// Empty sets
 			{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{}},
-			// Single behaviors
+			// Single behaviours
 			{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{consensusVote}},
 			// Equal Frequencies
 			{[]bh.PeerBehaviour{consensusVote, consensusVote},
@@ -100,9 +100,9 @@ func TestEqualPeerBehaviours(t *testing.T) {
 		}{
 			// Comparing empty sets to non empty sets
 			{[]bh.PeerBehaviour{}, []bh.PeerBehaviour{consensusVote}},
-			// Different behaviors
+			// Different behaviours
 			{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{blockPart}},
-			// Same behavior with different frequencies
+			// Same behaviour with different frequencies
 			{[]bh.PeerBehaviour{consensusVote},
 				[]bh.PeerBehaviour{consensusVote, consensusVote}},
 		}
@@ -128,8 +128,8 @@ func TestEqualPeerBehaviours(t *testing.T) {
 func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
 	var (
 		behaviourScript = []struct {
-			peerID    p2p.ID
-			behaviors []bh.PeerBehaviour
+			peerID     p2p.ID
+			behaviours []bh.PeerBehaviour
 		}{
 			{"1", []bh.PeerBehaviour{bh.ConsensusVote("1", "")}},
 			{"2", []bh.PeerBehaviour{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
@@ -166,7 +166,7 @@ func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
 			for {
 				select {
 				case pb := <-scriptItems:
-					if err := pr.Report(pb.behavior); err != nil {
+					if err := pr.Report(pb.behaviour); err != nil {
 						t.Error(err)
 					}
 				case <-done:
@@ -181,7 +181,7 @@ func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
 	go func() {
 		defer sendingWg.Done()
 		for _, item := range behaviourScript {
-			for _, reason := range item.behaviors {
+			for _, reason := range item.behaviours {
 				scriptItems <- scriptItem{item.peerID, reason}
 			}
 		}
@@ -197,9 +197,9 @@ func TestMockPeerBehaviourReporterConcurrency(t *testing.T) {
 
 	for _, items := range behaviourScript {
 		reported := pr.GetBehaviours(items.peerID)
-		if !equalBehaviours(reported, items.behaviors) {
+		if !equalBehaviours(reported, items.behaviours) {
 			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
-				items.peerID, items.behaviors, reported)
+				items.peerID, items.behaviours, reported)
 		}
 	}
 }

blockchain/v0/reactor.go

@@ -360,27 +360,15 @@ FOR_LOOP:
 				didProcessCh <- struct{}{}
 			}
 
-			firstParts, err := first.MakePartSet(types.BlockPartSizeBytes)
-			if err != nil {
-				bcR.Logger.Error("failed to make ",
-					"height", first.Height,
-					"err", err.Error())
-				break FOR_LOOP
-			}
+			firstParts := first.MakePartSet(types.BlockPartSizeBytes)
 			firstPartSetHeader := firstParts.Header()
 			firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
 			// Finally, verify the first block using the second's commit
 			// NOTE: we can probably make this more efficient, but note that calling
 			// first.Hash() doesn't verify the tx contents, so MakePartSet() is
 			// currently necessary.
-			err = state.Validators.VerifyCommitLight(
+			err := state.Validators.VerifyCommitLight(
 				chainID, firstID, first.Height, second.LastCommit)
-
-			if err == nil {
-				// validate the block before we persist it
-				err = bcR.blockExec.ValidateBlock(state, first)
-			}
-
 			if err != nil {
 				bcR.Logger.Error("Error in validation", "err", err)
 				peerID := bcR.pool.RedoRequest(first.Height)
@@ -398,29 +386,29 @@ FOR_LOOP:
 					bcR.Switch.StopPeerForError(peer2, fmt.Errorf("blockchainReactor validation error: %v", err))
 				}
 				continue FOR_LOOP
+			} else {
+				bcR.pool.PopRequest()
+
+				// TODO: batch saves so we dont persist to disk every block
+				bcR.store.SaveBlock(first, firstParts, second.LastCommit)
+
+				// TODO: same thing for app - but we would need a way to
+				// get the hash without persisting the state
+				var err error
+				state, _, err = bcR.blockExec.ApplyBlock(state, firstID, first)
+				if err != nil {
+					// TODO This is bad, are we zombie?
+					panic(fmt.Sprintf("Failed to process committed block (%d:%X): %v", first.Height, first.Hash(), err))
+				}
+				blocksSynced++
+
+				if blocksSynced%100 == 0 {
+					lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
+					bcR.Logger.Info("Fast Sync Rate", "height", bcR.pool.height,
+						"max_peer_height", bcR.pool.MaxPeerHeight(), "blocks/s", lastRate)
+					lastHundred = time.Now()
+				}
 			}
-
-			bcR.pool.PopRequest()
-
-			// TODO: batch saves so we dont persist to disk every block
-			bcR.store.SaveBlock(first, firstParts, second.LastCommit)
-
-			// TODO: same thing for app - but we would need a way to
-			// get the hash without persisting the state
-			state, _, err = bcR.blockExec.ApplyBlock(state, firstID, first)
-			if err != nil {
-				// TODO This is bad, are we zombie?
-				panic(fmt.Sprintf("Failed to process committed block (%d:%X): %v", first.Height, first.Hash(), err))
-			}
-			blocksSynced++
-
-			if blocksSynced%100 == 0 {
-				lastRate = 0.9*lastRate + 0.1*(100/time.Since(lastHundred).Seconds())
-				bcR.Logger.Info("Fast Sync Rate", "height", bcR.pool.height,
-					"max_peer_height", bcR.pool.MaxPeerHeight(), "blocks/s", lastRate)
-				lastHundred = time.Now()
-			}
-
 			continue FOR_LOOP
 
 		case <-bcR.Quit():

blockchain/v0/reactor_test.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
 	dbm "github.com/tendermint/tm-db"
@@ -16,11 +15,10 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
-	mpmocks "github.com/tendermint/tendermint/mempool/mocks"
+	"github.com/tendermint/tendermint/mempool/mock"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
-	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
@@ -54,7 +52,6 @@ type BlockchainReactorPair struct {
 }
 
 func newBlockchainReactor(
-	t *testing.T,
 	logger log.Logger,
 	genDoc *types.GenesisDoc,
 	privVals []types.PrivValidator,
@@ -81,18 +78,6 @@ func newBlockchainReactor(
 		panic(fmt.Errorf("error constructing state from genesis file: %w", err))
 	}
 
-	mp := &mpmocks.Mempool{}
-	mp.On("Lock").Return()
-	mp.On("Unlock").Return()
-	mp.On("FlushAppConn", mock.Anything).Return(nil)
-	mp.On("Update",
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything).Return(nil)
-
 	// Make the BlockchainReactor itself.
 	// NOTE we have to create and commit the blocks first because
 	// pool.height is determined from the store.
@@ -100,7 +85,7 @@ func newBlockchainReactor(
 	db := dbm.NewMemDB()
 	stateStore = sm.NewStore(db)
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
-		mp, sm.EmptyEvidencePool{})
+		mock.Mempool{}, sm.EmptyEvidencePool{})
 	if err = stateStore.Save(state); err != nil {
 		panic(err)
 	}
@@ -127,10 +112,9 @@ func newBlockchainReactor(
 				lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
 		}
 
-		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)
+		thisBlock := makeBlock(blockHeight, state, lastCommit)
 
-		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		require.NoError(t, err)
+		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
@@ -156,8 +140,8 @@ func TestNoBlockResponse(t *testing.T) {
 
 	reactorPairs := make([]BlockchainReactorPair, 2)
 
-	reactorPairs[0] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, maxBlockHeight)
-	reactorPairs[1] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, 0)
+	reactorPairs[0] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
+	reactorPairs[1] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
 
 	p2p.MakeConnectedSwitches(config.P2P, 2, func(i int, s *p2p.Switch) *p2p.Switch {
 		s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
@@ -218,7 +202,7 @@ func TestBadBlockStopsPeer(t *testing.T) {
 
 	// Other chain needs a different validator set
 	otherGenDoc, otherPrivVals := randGenesisDoc(1, false, 30)
-	otherChain := newBlockchainReactor(t, log.TestingLogger(), otherGenDoc, otherPrivVals, maxBlockHeight)
+	otherChain := newBlockchainReactor(log.TestingLogger(), otherGenDoc, otherPrivVals, maxBlockHeight)
 
 	defer func() {
 		err := otherChain.reactor.Stop()
@@ -229,10 +213,10 @@ func TestBadBlockStopsPeer(t *testing.T) {
 
 	reactorPairs := make([]BlockchainReactorPair, 4)
 
-	reactorPairs[0] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, maxBlockHeight)
-	reactorPairs[1] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, 0)
-	reactorPairs[2] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, 0)
-	reactorPairs[3] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, 0)
+	reactorPairs[0] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
+	reactorPairs[1] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
+	reactorPairs[2] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
+	reactorPairs[3] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
 
 	switches := p2p.MakeConnectedSwitches(config.P2P, 4, func(i int, s *p2p.Switch) *p2p.Switch {
 		s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
@@ -270,7 +254,7 @@ func TestBadBlockStopsPeer(t *testing.T) {
 	// race, but can't be easily avoided.
 	reactorPairs[3].reactor.store = otherChain.reactor.store
 
-	lastReactorPair := newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, 0)
+	lastReactorPair := newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
 	reactorPairs = append(reactorPairs, lastReactorPair)
 
 	switches = append(switches, p2p.MakeConnectedSwitches(config.P2P, 1, func(i int, s *p2p.Switch) *p2p.Switch {
@@ -294,6 +278,21 @@ func TestBadBlockStopsPeer(t *testing.T) {
 	assert.True(t, lastReactorPair.reactor.Switch.Peers().Size() < len(reactorPairs)-1)
 }
 
+//----------------------------------------------
+// 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
 }

blockchain/v1/reactor.go

@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"time"
 
-	"github.com/tendermint/tendermint/behaviour" //nolint:misspell
+	"github.com/tendermint/tendermint/behaviour"
 	bc "github.com/tendermint/tendermint/blockchain"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/p2p"
@@ -100,7 +100,7 @@ func NewBlockchainReactor(state sm.State, blockExec *sm.BlockExecutor, store *st
 	fsm := NewFSM(startHeight, bcR)
 	bcR.fsm = fsm
 	bcR.BaseReactor = *p2p.NewBaseReactor("BlockchainReactor", bcR)
-	// bcR.swReporter = behavior.NewSwitchReporter(bcR.BaseReactor.Switch)
+	// bcR.swReporter = behaviour.NewSwitchReporter(bcR.BaseReactor.Switch)
 
 	return bcR
 }
@@ -465,13 +465,7 @@ func (bcR *BlockchainReactor) processBlock() error {
 
 	chainID := bcR.initialState.ChainID
 
-	firstParts, err := first.MakePartSet(types.BlockPartSizeBytes)
-	if err != nil {
-		bcR.Logger.Error("failed to make ",
-			"height", first.Height,
-			"err", err.Error())
-		return err
-	}
+	firstParts := first.MakePartSet(types.BlockPartSizeBytes)
 	firstPartSetHeader := firstParts.Header()
 	firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
 	// Finally, verify the first block using the second's commit

blockchain/v1/reactor_test.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
 	dbm "github.com/tendermint/tm-db"
@@ -17,12 +16,11 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
-	mpmocks "github.com/tendermint/tendermint/mempool/mocks"
+	"github.com/tendermint/tendermint/mempool/mock"
 	"github.com/tendermint/tendermint/p2p"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
-	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
@@ -112,18 +110,6 @@ func newBlockchainReactor(
 		panic(fmt.Errorf("error constructing state from genesis file: %w", err))
 	}
 
-	mp := &mpmocks.Mempool{}
-	mp.On("Lock").Return()
-	mp.On("Unlock").Return()
-	mp.On("FlushAppConn", mock.Anything).Return(nil)
-	mp.On("Update",
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything).Return(nil)
-
 	// Make the BlockchainReactor itself.
 	// NOTE we have to create and commit the blocks first because
 	// pool.height is determined from the store.
@@ -131,7 +117,7 @@ func newBlockchainReactor(
 	db := dbm.NewMemDB()
 	stateStore = sm.NewStore(db)
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
-		mp, sm.EmptyEvidencePool{})
+		mock.Mempool{}, sm.EmptyEvidencePool{})
 	if err = stateStore.Save(state); err != nil {
 		panic(err)
 	}
@@ -147,10 +133,9 @@ func newBlockchainReactor(
 			lastCommit = types.NewCommit(vote.Height, vote.Round, lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
 		}
 
-		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)
+		thisBlock := makeBlock(blockHeight, state, lastCommit)
 
-		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		require.NoError(t, err)
+		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
 
 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
@@ -360,6 +345,21 @@ outerFor:
 	assert.True(t, lastReactorPair.bcR.Switch.Peers().Size() < len(reactorPairs)-1)
 }
 
+//----------------------------------------------
+// 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
 }

blockchain/v2/processor.go

@@ -158,12 +158,11 @@ func (state *pcState) handle(event Event) (Event, error) {
 			return noOp, nil
 		}
 
-		first, second := firstItem.block, secondItem.block
-		firstParts, err := first.MakePartSet(types.BlockPartSizeBytes)
-		if err != nil {
-			panic(fmt.Sprintf("failed to make part set, height %d: %v ", first.Height, err.Error()))
-		}
-		firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstParts.Header()}
+		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)

blockchain/v2/processor_test.go

@@ -82,7 +82,7 @@ func executeProcessorTests(t *testing.T, tests []testFields) {
 					}
 				}()
 
-				// First step must always initialize the currentState as state.
+				// First step must always initialise the currentState as state.
 				if step.currentState != nil {
 					state = makeState(step.currentState)
 				}

blockchain/v2/reactor.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/tendermint/tendermint/behaviour" //nolint:misspell
+	"github.com/tendermint/tendermint/behaviour"
 	bc "github.com/tendermint/tendermint/blockchain"
 	"github.com/tendermint/tendermint/libs/log"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
@@ -139,7 +139,7 @@ func (r *BlockchainReactor) Start() error {
 	return nil
 }
 
-// startSync begins a fast sync, signaled by r.events being non-nil. If state is non-nil,
+// startSync begins a fast sync, signalled 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()

blockchain/v2/reactor_test.go

@@ -10,23 +10,21 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	dbm "github.com/tendermint/tm-db"
 
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/behaviour" //nolint:misspell
+	"github.com/tendermint/tendermint/behaviour"
 	bc "github.com/tendermint/tendermint/blockchain"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
-	mpmocks "github.com/tendermint/tendermint/mempool/mocks"
+	"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"
-	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
 	tmtime "github.com/tendermint/tendermint/types/time"
@@ -144,8 +142,8 @@ type testReactorParams struct {
 	mockA       bool
 }
 
-func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
-	store, state, _ := newReactorStore(t, p.genDoc, p.privVals, p.startHeight)
+func newTestReactor(p testReactorParams) *BlockchainReactor {
+	store, state, _ := newReactorStore(p.genDoc, p.privVals, p.startHeight)
 	reporter := behaviour.NewMockReporter()
 
 	var appl blockApplier
@@ -153,18 +151,6 @@ func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
 	if p.mockA {
 		appl = &mockBlockApplier{}
 	} else {
-		mp := &mpmocks.Mempool{}
-		mp.On("Lock").Return()
-		mp.On("Unlock").Return()
-		mp.On("FlushAppConn", mock.Anything).Return(nil)
-		mp.On("Update",
-			mock.Anything,
-			mock.Anything,
-			mock.Anything,
-			mock.Anything,
-			mock.Anything,
-			mock.Anything).Return(nil)
-
 		app := &testApp{}
 		cc := proxy.NewLocalClientCreator(app)
 		proxyApp := proxy.NewAppConns(cc)
@@ -174,7 +160,7 @@ func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
 		}
 		db := dbm.NewMemDB()
 		stateStore := sm.NewStore(db)
-		appl = sm.NewBlockExecutor(stateStore, p.logger, proxyApp.Consensus(), mp, sm.EmptyEvidencePool{})
+		appl = sm.NewBlockExecutor(stateStore, p.logger, proxyApp.Consensus(), mock.Mempool{}, sm.EmptyEvidencePool{})
 		if err = stateStore.Save(state); err != nil {
 			panic(err)
 		}
@@ -315,7 +301,7 @@ func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
 // 		t.Run(tt.name, func(t *testing.T) {
 // 			reactor := newTestReactor(params)
 // 			reactor.Start()
-// 			reactor.reporter = behavior.NewMockReporter()
+// 			reactor.reporter = behaviour.NewMockReporter()
 // 			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
 // 			reactor.io = mockSwitch
 // 			// time for go routines to start
@@ -405,7 +391,7 @@ func TestReactorHelperMode(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			reactor := newTestReactor(t, params)
+			reactor := newTestReactor(params)
 			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
 			reactor.io = mockSwitch
 			err := reactor.Start()
@@ -448,7 +434,7 @@ func TestReactorSetSwitchNil(t *testing.T) {
 	defer os.RemoveAll(config.RootDir)
 	genDoc, privVals := randGenesisDoc(config.ChainID(), 1, false, 30)
 
-	reactor := newTestReactor(t, testReactorParams{
+	reactor := newTestReactor(testReactorParams{
 		logger:   log.TestingLogger(),
 		genDoc:   genDoc,
 		privVals: privVals,
@@ -459,6 +445,21 @@ func TestReactorSetSwitchNil(t *testing.T) {
 	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
 }
@@ -487,7 +488,6 @@ func randGenesisDoc(chainID string, numValidators int, randPower bool, minPower
 // Why are we importing the entire blockExecutor dependency graph here
 // when we have the facilities to
 func newReactorStore(
-	t *testing.T,
 	genDoc *types.GenesisDoc,
 	privVals []types.PrivValidator,
 	maxBlockHeight int64) (*store.BlockStore, sm.State, *sm.BlockExecutor) {
@@ -510,22 +510,10 @@ func newReactorStore(
 		panic(fmt.Errorf("error constructing state from genesis file: %w", err))
 	}
 
-	mp := &mpmocks.Mempool{}
-	mp.On("Lock").Return()
-	mp.On("Unlock").Return()
-	mp.On("FlushAppConn", mock.Anything).Return(nil)
-	mp.On("Update",
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything,
-		mock.Anything).Return(nil)
-
 	db := dbm.NewMemDB()
 	stateStore = sm.NewStore(db)
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
-		mp, sm.EmptyEvidencePool{})
+		mock.Mempool{}, sm.EmptyEvidencePool{})
 	if err = stateStore.Save(state); err != nil {
 		panic(err)
 	}
@@ -551,11 +539,9 @@ func newReactorStore(
 				lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
 		}
 
-		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)
-
-		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		require.NoError(t, err)
+		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)

blockchain/v2/routine.go

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

blockchain/v2/scheduler_test.go

@@ -2225,7 +2225,7 @@ func TestScHandle(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			var sc *scheduler
 			for i, step := range tt.steps {
-				// First step must always initialize the currentState as state.
+				// First step must always initialise the currentState as state.
 				if step.currentSc != nil {
 					sc = newTestScheduler(*step.currentSc)
 				}

buf.gen.yaml

@@ -1,9 +0,0 @@
-version: v1
-plugins:
-  - name: gogofaster
-    out: ./proto/
-    opt:
-      - Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types
-      - Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration
-      - plugins=grpc
-      - paths=source_relative

buf.work.yaml

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

cmd/tendermint/commands/compact.go

@@ -1,66 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"path/filepath"
-	"sync"
-
-	"github.com/spf13/cobra"
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/opt"
-	"github.com/syndtr/goleveldb/leveldb/util"
-
-	"github.com/tendermint/tendermint/libs/log"
-)
-
-var CompactGoLevelDBCmd = &cobra.Command{
-	Use:   "experimental-compact-goleveldb",
-	Short: "force compacts the tendermint storage engine (only GoLevelDB supported)",
-	Long: `
-This is a temporary utility command that performs a force compaction on the state 
-and blockstores to reduce disk space for a pruning node. This should only be run 
-once the node has stopped. This command will likely be omitted in the future after
-the planned refactor to the storage engine.
-
-Currently, only GoLevelDB is supported.
-	`,
-	RunE: func(cmd *cobra.Command, args []string) error {
-		if config.DBBackend != "goleveldb" {
-			return errors.New("compaction is currently only supported with goleveldb")
-		}
-
-		compactGoLevelDBs(config.RootDir, logger)
-		return nil
-	},
-}
-
-func compactGoLevelDBs(rootDir string, logger log.Logger) {
-	dbNames := []string{"state", "blockstore"}
-	o := &opt.Options{
-		DisableSeeksCompaction: true,
-	}
-	wg := sync.WaitGroup{}
-
-	for _, dbName := range dbNames {
-		dbName := dbName
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			dbPath := filepath.Join(rootDir, "data", dbName+".db")
-			store, err := leveldb.OpenFile(dbPath, o)
-			if err != nil {
-				logger.Error("failed to initialize tendermint db", "path", dbPath, "err", err)
-				return
-			}
-			defer store.Close()
-
-			logger.Info("starting compaction...", "db", dbPath)
-
-			err = store.CompactRange(util.Range{Start: nil, Limit: nil})
-			if err != nil {
-				logger.Error("failed to compact tendermint db", "path", dbPath, "err", err)
-			}
-		}()
-	}
-	wg.Wait()
-}

cmd/tendermint/commands/init.go

@@ -14,7 +14,7 @@ import (
 	tmtime "github.com/tendermint/tendermint/types/time"
 )
 
-// InitFilesCmd initializes a fresh Tendermint Core instance.
+// InitFilesCmd initialises a fresh Tendermint Core instance.
 var InitFilesCmd = &cobra.Command{
 	Use:   "init",
 	Short: "Initialize Tendermint",

cmd/tendermint/commands/light.go

@@ -101,7 +101,7 @@ func init() {
 }
 
 func runProxy(cmd *cobra.Command, args []string) error {
-	// Initialize logger.
+	// Initialise logger.
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
 	var option log.Option
 	if verbose {

cmd/tendermint/commands/reindex_event.go

@@ -1,229 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/spf13/cobra"
-	dbm "github.com/tendermint/tm-db"
-
-	abcitypes "github.com/tendermint/tendermint/abci/types"
-	tmcfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/libs/progressbar"
-	"github.com/tendermint/tendermint/state"
-	"github.com/tendermint/tendermint/state/indexer"
-	blockidxkv "github.com/tendermint/tendermint/state/indexer/block/kv"
-	"github.com/tendermint/tendermint/state/indexer/sink/psql"
-	"github.com/tendermint/tendermint/state/txindex"
-	"github.com/tendermint/tendermint/state/txindex/kv"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	reindexFailed = "event re-index failed: "
-)
-
-var (
-	ErrHeightNotAvailable = errors.New("height is not available")
-	ErrInvalidRequest     = errors.New("invalid request")
-)
-
-// ReIndexEventCmd constructs a command to re-index events in a block height interval.
-var ReIndexEventCmd = &cobra.Command{
-	Use:   "reindex-event",
-	Short: "reindex events to the event store backends",
-	Long: `
-reindex-event is an offline tooling to re-index block and tx events to the eventsinks,
-you can run this command when the event store backend dropped/disconnected or you want to 
-replace the backend. The default start-height is 0, meaning the tooling will start 
-reindex from the base block height(inclusive); and the default end-height is 0, meaning 
-the tooling will reindex until the latest block height(inclusive). User can omit
-either or both arguments.
-	`,
-	Example: `
-	tendermint reindex-event
-	tendermint reindex-event --start-height 2
-	tendermint reindex-event --end-height 10
-	tendermint reindex-event --start-height 2 --end-height 10
-	`,
-	Run: func(cmd *cobra.Command, args []string) {
-		bs, ss, err := loadStateAndBlockStore(config)
-		if err != nil {
-			fmt.Println(reindexFailed, err)
-			return
-		}
-
-		if err := checkValidHeight(bs); err != nil {
-			fmt.Println(reindexFailed, err)
-			return
-		}
-
-		bi, ti, err := loadEventSinks(config)
-		if err != nil {
-			fmt.Println(reindexFailed, err)
-			return
-		}
-
-		riArgs := eventReIndexArgs{
-			startHeight:  startHeight,
-			endHeight:    endHeight,
-			blockIndexer: bi,
-			txIndexer:    ti,
-			blockStore:   bs,
-			stateStore:   ss,
-		}
-		if err := eventReIndex(cmd, riArgs); err != nil {
-			panic(fmt.Errorf("%s: %w", reindexFailed, err))
-		}
-
-		fmt.Println("event re-index finished")
-	},
-}
-
-var (
-	startHeight int64
-	endHeight   int64
-)
-
-func init() {
-	ReIndexEventCmd.Flags().Int64Var(&startHeight, "start-height", 0, "the block height would like to start for re-index")
-	ReIndexEventCmd.Flags().Int64Var(&endHeight, "end-height", 0, "the block height would like to finish for re-index")
-}
-
-func loadEventSinks(cfg *tmcfg.Config) (indexer.BlockIndexer, txindex.TxIndexer, error) {
-	switch strings.ToLower(cfg.TxIndex.Indexer) {
-	case "null":
-		return nil, nil, errors.New("found null event sink, please check the tx-index section in the config.toml")
-	case "psql":
-		conn := cfg.TxIndex.PsqlConn
-		if conn == "" {
-			return nil, nil, errors.New("the psql connection settings cannot be empty")
-		}
-		es, err := psql.NewEventSink(conn, cfg.ChainID())
-		if err != nil {
-			return nil, nil, err
-		}
-		return es.BlockIndexer(), es.TxIndexer(), nil
-	case "kv":
-		store, err := dbm.NewDB("tx_index", dbm.BackendType(cfg.DBBackend), cfg.DBDir())
-		if err != nil {
-			return nil, nil, err
-		}
-
-		txIndexer := kv.NewTxIndex(store)
-		blockIndexer := blockidxkv.New(dbm.NewPrefixDB(store, []byte("block_events")))
-		return blockIndexer, txIndexer, nil
-	default:
-		return nil, nil, fmt.Errorf("unsupported event sink type: %s", cfg.TxIndex.Indexer)
-	}
-}
-
-type eventReIndexArgs struct {
-	startHeight  int64
-	endHeight    int64
-	blockIndexer indexer.BlockIndexer
-	txIndexer    txindex.TxIndexer
-	blockStore   state.BlockStore
-	stateStore   state.Store
-}
-
-func eventReIndex(cmd *cobra.Command, args eventReIndexArgs) error {
-	var bar progressbar.Bar
-	bar.NewOption(args.startHeight-1, args.endHeight)
-
-	fmt.Println("start re-indexing events:")
-	defer bar.Finish()
-	for i := args.startHeight; i <= args.endHeight; i++ {
-		select {
-		case <-cmd.Context().Done():
-			return fmt.Errorf("event re-index terminated at height %d: %w", i, cmd.Context().Err())
-		default:
-			b := args.blockStore.LoadBlock(i)
-			if b == nil {
-				return fmt.Errorf("not able to load block at height %d from the blockstore", i)
-			}
-
-			r, err := args.stateStore.LoadABCIResponses(i)
-			if err != nil {
-				return fmt.Errorf("not able to load ABCI Response at height %d from the statestore", i)
-			}
-
-			e := types.EventDataNewBlockHeader{
-				Header:           b.Header,
-				NumTxs:           int64(len(b.Txs)),
-				ResultBeginBlock: *r.BeginBlock,
-				ResultEndBlock:   *r.EndBlock,
-			}
-
-			var batch *txindex.Batch
-			if e.NumTxs > 0 {
-				batch = txindex.NewBatch(e.NumTxs)
-
-				for i := range b.Data.Txs {
-					tr := abcitypes.TxResult{
-						Height: b.Height,
-						Index:  uint32(i),
-						Tx:     b.Data.Txs[i],
-						Result: *(r.DeliverTxs[i]),
-					}
-
-					if err = batch.Add(&tr); err != nil {
-						return fmt.Errorf("adding tx to batch: %w", err)
-					}
-				}
-
-				if err := args.txIndexer.AddBatch(batch); err != nil {
-					return fmt.Errorf("tx event re-index at height %d failed: %w", i, err)
-				}
-			}
-
-			if err := args.blockIndexer.Index(e); err != nil {
-				return fmt.Errorf("block event re-index at height %d failed: %w", i, err)
-			}
-		}
-
-		bar.Play(i)
-	}
-
-	return nil
-}
-
-func checkValidHeight(bs state.BlockStore) error {
-	base := bs.Base()
-
-	if startHeight == 0 {
-		startHeight = base
-		fmt.Printf("set the start block height to the base height of the blockstore %d \n", base)
-	}
-
-	if startHeight < base {
-		return fmt.Errorf("%s (requested start height: %d, base height: %d)",
-			ErrHeightNotAvailable, startHeight, base)
-	}
-
-	height := bs.Height()
-
-	if startHeight > height {
-		return fmt.Errorf(
-			"%s (requested start height: %d, store height: %d)", ErrHeightNotAvailable, startHeight, height)
-	}
-
-	if endHeight == 0 || endHeight > height {
-		endHeight = height
-		fmt.Printf("set the end block height to the latest height of the blockstore %d \n", height)
-	}
-
-	if endHeight < base {
-		return fmt.Errorf(
-			"%s (requested end height: %d, base height: %d)", ErrHeightNotAvailable, endHeight, base)
-	}
-
-	if endHeight < startHeight {
-		return fmt.Errorf(
-			"%s (requested the end height: %d is less than the start height: %d)",
-			ErrInvalidRequest, startHeight, endHeight)
-	}
-
-	return nil
-}

cmd/tendermint/commands/reindex_event_test.go

@@ -1,193 +0,0 @@
-package commands
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-
-	dbm "github.com/tendermint/tm-db"
-
-	abcitypes "github.com/tendermint/tendermint/abci/types"
-	tmcfg "github.com/tendermint/tendermint/config"
-	prototmstate "github.com/tendermint/tendermint/proto/tendermint/state"
-	blockmocks "github.com/tendermint/tendermint/state/indexer/mocks"
-	"github.com/tendermint/tendermint/state/mocks"
-	txmocks "github.com/tendermint/tendermint/state/txindex/mocks"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	height int64 = 10
-	base   int64 = 2
-)
-
-func setupReIndexEventCmd() *cobra.Command {
-	reIndexEventCmd := &cobra.Command{
-		Use: ReIndexEventCmd.Use,
-		Run: func(cmd *cobra.Command, args []string) {},
-	}
-
-	_ = reIndexEventCmd.ExecuteContext(context.Background())
-
-	return reIndexEventCmd
-}
-
-func TestReIndexEventCheckHeight(t *testing.T) {
-	mockBlockStore := &mocks.BlockStore{}
-	mockBlockStore.
-		On("Base").Return(base).
-		On("Height").Return(height)
-
-	testCases := []struct {
-		startHeight int64
-		endHeight   int64
-		validHeight bool
-	}{
-		{0, 0, true},
-		{0, base, true},
-		{0, base - 1, false},
-		{0, height, true},
-		{0, height + 1, true},
-		{0, 0, true},
-		{base - 1, 0, false},
-		{base, 0, true},
-		{base, base, true},
-		{base, base - 1, false},
-		{base, height, true},
-		{base, height + 1, true},
-		{height, 0, true},
-		{height, base, false},
-		{height, height - 1, false},
-		{height, height, true},
-		{height, height + 1, true},
-		{height + 1, 0, false},
-	}
-
-	for _, tc := range testCases {
-		startHeight = tc.startHeight
-		endHeight = tc.endHeight
-
-		err := checkValidHeight(mockBlockStore)
-		if tc.validHeight {
-			require.NoError(t, err)
-		} else {
-			require.Error(t, err)
-		}
-	}
-}
-
-func TestLoadEventSink(t *testing.T) {
-	testCases := []struct {
-		sinks   string
-		connURL string
-		loadErr bool
-	}{
-		{"", "", true},
-		{"NULL", "", true},
-		{"KV", "", false},
-		{"PSQL", "", true}, // true because empty connect url
-		// skip to test PSQL connect with correct url
-		{"UnsupportedSinkType", "wrongUrl", true},
-	}
-
-	for idx, tc := range testCases {
-		cfg := tmcfg.TestConfig()
-		cfg.TxIndex.Indexer = tc.sinks
-		cfg.TxIndex.PsqlConn = tc.connURL
-		_, _, err := loadEventSinks(cfg)
-		if tc.loadErr {
-			require.Error(t, err, idx)
-		} else {
-			require.NoError(t, err, idx)
-		}
-	}
-}
-
-func TestLoadBlockStore(t *testing.T) {
-	cfg := tmcfg.TestConfig()
-	cfg.DBPath = t.TempDir()
-	_, _, err := loadStateAndBlockStore(cfg)
-	require.Error(t, err)
-
-	_, err = dbm.NewDB("blockstore", dbm.GoLevelDBBackend, cfg.DBDir())
-	require.NoError(t, err)
-
-	// Get StateStore
-	_, err = dbm.NewDB("state", dbm.GoLevelDBBackend, cfg.DBDir())
-	require.NoError(t, err)
-
-	bs, ss, err := loadStateAndBlockStore(cfg)
-	require.NoError(t, err)
-	require.NotNil(t, bs)
-	require.NotNil(t, ss)
-
-}
-
-func TestReIndexEvent(t *testing.T) {
-	mockBlockStore := &mocks.BlockStore{}
-	mockStateStore := &mocks.Store{}
-	mockBlockIndexer := &blockmocks.BlockIndexer{}
-	mockTxIndexer := &txmocks.TxIndexer{}
-
-	mockBlockStore.
-		On("Base").Return(base).
-		On("Height").Return(height).
-		On("LoadBlock", base).Return(nil).Once().
-		On("LoadBlock", base).Return(&types.Block{Data: types.Data{Txs: types.Txs{make(types.Tx, 1)}}}).
-		On("LoadBlock", height).Return(&types.Block{Data: types.Data{Txs: types.Txs{make(types.Tx, 1)}}})
-
-	dtx := abcitypes.ResponseDeliverTx{}
-	abciResp := &prototmstate.ABCIResponses{
-		DeliverTxs: []*abcitypes.ResponseDeliverTx{&dtx},
-		EndBlock:   &abcitypes.ResponseEndBlock{},
-		BeginBlock: &abcitypes.ResponseBeginBlock{},
-	}
-
-	mockBlockIndexer.
-		On("Index", mock.AnythingOfType("types.EventDataNewBlockHeader")).Return(errors.New("")).Once().
-		On("Index", mock.AnythingOfType("types.EventDataNewBlockHeader")).Return(nil)
-
-	mockTxIndexer.
-		On("AddBatch", mock.AnythingOfType("*txindex.Batch")).Return(errors.New("")).Once().
-		On("AddBatch", mock.AnythingOfType("*txindex.Batch")).Return(nil)
-
-	mockStateStore.
-		On("LoadABCIResponses", base).Return(nil, errors.New("")).Once().
-		On("LoadABCIResponses", base).Return(abciResp, nil).
-		On("LoadABCIResponses", height).Return(abciResp, nil)
-
-	testCases := []struct {
-		startHeight int64
-		endHeight   int64
-		reIndexErr  bool
-	}{
-		{base, height, true}, // LoadBlock error
-		{base, height, true}, // LoadABCIResponses error
-		{base, height, true}, // index block event error
-		{base, height, true}, // index tx event error
-		{base, base, false},
-		{height, height, false},
-	}
-
-	for _, tc := range testCases {
-		args := eventReIndexArgs{
-			startHeight:  tc.startHeight,
-			endHeight:    tc.endHeight,
-			blockIndexer: mockBlockIndexer,
-			txIndexer:    mockTxIndexer,
-			blockStore:   mockBlockStore,
-			stateStore:   mockStateStore,
-		}
-
-		err := eventReIndex(setupReIndexEventCmd(), args)
-		if tc.reIndexErr {
-			require.Error(t, err)
-		} else {
-			require.NoError(t, err)
-		}
-	}
-}

cmd/tendermint/commands/reset.go

@@ -1,186 +0,0 @@
-package commands
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/spf13/cobra"
-
-	"github.com/tendermint/tendermint/libs/log"
-	tmos "github.com/tendermint/tendermint/libs/os"
-	"github.com/tendermint/tendermint/privval"
-)
-
-// ResetAllCmd removes the database of this Tendermint core
-// instance.
-var ResetAllCmd = &cobra.Command{
-	Use:     "unsafe-reset-all",
-	Aliases: []string{"unsafe_reset_all"},
-	Short:   "(unsafe) Remove all the data and WAL, reset this node's validator to genesis state",
-	RunE:    resetAllCmd,
-	PreRun:  deprecateSnakeCase,
-}
-
-var keepAddrBook bool
-
-// ResetStateCmd removes the database of the specified Tendermint core instance.
-var ResetStateCmd = &cobra.Command{
-	Use:    "reset-state",
-	Short:  "Remove all the data and WAL",
-	PreRun: deprecateSnakeCase,
-	RunE: func(cmd *cobra.Command, args []string) (err error) {
-		config, err = ParseConfig()
-		if err != nil {
-			return err
-		}
-
-		return resetState(config.DBDir(), logger)
-	},
-}
-
-func init() {
-	ResetAllCmd.Flags().BoolVar(&keepAddrBook, "keep-addr-book", false, "keep the address book intact")
-}
-
-// ResetPrivValidatorCmd resets the private validator files.
-var ResetPrivValidatorCmd = &cobra.Command{
-	Use:     "unsafe-reset-priv-validator",
-	Aliases: []string{"unsafe_reset_priv_validator"},
-	Short:   "(unsafe) Reset this node's validator to genesis state",
-	PreRun:  deprecateSnakeCase,
-	RunE:    resetPrivValidator,
-}
-
-// XXX: this is totally unsafe.
-// it's only suitable for testnets.
-func resetAllCmd(cmd *cobra.Command, args []string) (err error) {
-	config, err = ParseConfig()
-	if err != nil {
-		return err
-	}
-
-	return resetAll(
-		config.DBDir(),
-		config.P2P.AddrBookFile(),
-		config.PrivValidatorKeyFile(),
-		config.PrivValidatorStateFile(),
-		logger,
-	)
-}
-
-// XXX: this is totally unsafe.
-// it's only suitable for testnets.
-func resetPrivValidator(cmd *cobra.Command, args []string) (err error) {
-	config, err = ParseConfig()
-	if err != nil {
-		return err
-	}
-
-	resetFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile(), logger)
-	return nil
-}
-
-// resetAll removes address book files plus all data, and resets the privValdiator data.
-func resetAll(dbDir, addrBookFile, privValKeyFile, privValStateFile string, logger log.Logger) error {
-	if keepAddrBook {
-		logger.Info("The address book remains intact")
-	} else {
-		removeAddrBook(addrBookFile, logger)
-	}
-
-	if err := os.RemoveAll(dbDir); err == nil {
-		logger.Info("Removed all blockchain history", "dir", dbDir)
-	} else {
-		logger.Error("Error removing all blockchain history", "dir", dbDir, "err", err)
-	}
-
-	if err := tmos.EnsureDir(dbDir, 0700); err != nil {
-		logger.Error("unable to recreate dbDir", "err", err)
-	}
-
-	// recreate the dbDir since the privVal state needs to live there
-	resetFilePV(privValKeyFile, privValStateFile, logger)
-	return nil
-}
-
-// resetState removes address book files plus all databases.
-func resetState(dbDir string, logger log.Logger) error {
-	blockdb := filepath.Join(dbDir, "blockstore.db")
-	state := filepath.Join(dbDir, "state.db")
-	wal := filepath.Join(dbDir, "cs.wal")
-	evidence := filepath.Join(dbDir, "evidence.db")
-	txIndex := filepath.Join(dbDir, "tx_index.db")
-
-	if tmos.FileExists(blockdb) {
-		if err := os.RemoveAll(blockdb); err == nil {
-			logger.Info("Removed all blockstore.db", "dir", blockdb)
-		} else {
-			logger.Error("error removing all blockstore.db", "dir", blockdb, "err", err)
-		}
-	}
-
-	if tmos.FileExists(state) {
-		if err := os.RemoveAll(state); err == nil {
-			logger.Info("Removed all state.db", "dir", state)
-		} else {
-			logger.Error("error removing all state.db", "dir", state, "err", err)
-		}
-	}
-
-	if tmos.FileExists(wal) {
-		if err := os.RemoveAll(wal); err == nil {
-			logger.Info("Removed all cs.wal", "dir", wal)
-		} else {
-			logger.Error("error removing all cs.wal", "dir", wal, "err", err)
-		}
-	}
-
-	if tmos.FileExists(evidence) {
-		if err := os.RemoveAll(evidence); err == nil {
-			logger.Info("Removed all evidence.db", "dir", evidence)
-		} else {
-			logger.Error("error removing all evidence.db", "dir", evidence, "err", err)
-		}
-	}
-
-	if tmos.FileExists(txIndex) {
-		if err := os.RemoveAll(txIndex); err == nil {
-			logger.Info("Removed tx_index.db", "dir", txIndex)
-		} else {
-			logger.Error("error removing tx_index.db", "dir", txIndex, "err", err)
-		}
-	}
-
-	if err := tmos.EnsureDir(dbDir, 0700); err != nil {
-		logger.Error("unable to recreate dbDir", "err", err)
-	}
-	return nil
-}
-
-func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger) {
-	if _, err := os.Stat(privValKeyFile); err == nil {
-		pv := privval.LoadFilePVEmptyState(privValKeyFile, privValStateFile)
-		pv.Reset()
-		logger.Info(
-			"Reset private validator file to genesis state",
-			"keyFile", privValKeyFile,
-			"stateFile", privValStateFile,
-		)
-	} else {
-		pv := privval.GenFilePV(privValKeyFile, privValStateFile)
-		pv.Save()
-		logger.Info(
-			"Generated private validator file",
-			"keyFile", privValKeyFile,
-			"stateFile", privValStateFile,
-		)
-	}
-}
-
-func removeAddrBook(addrBookFile string, logger log.Logger) {
-	if err := os.Remove(addrBookFile); err == nil {
-		logger.Info("Removed existing address book", "file", addrBookFile)
-	} else if !os.IsNotExist(err) {
-		logger.Info("Error removing address book", "file", addrBookFile, "err", err)
-	}
-}

cmd/tendermint/commands/reset_priv_validator.go

@@ -0,0 +1,91 @@
+package commands
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/tendermint/tendermint/libs/log"
+	tmos "github.com/tendermint/tendermint/libs/os"
+	"github.com/tendermint/tendermint/privval"
+)
+
+// ResetAllCmd removes the database of this Tendermint core
+// instance.
+var ResetAllCmd = &cobra.Command{
+	Use:     "unsafe-reset-all",
+	Aliases: []string{"unsafe_reset_all"},
+	Short:   "(unsafe) Remove all the data and WAL, reset this node's validator to genesis state",
+	Run:     resetAll,
+	PreRun:  deprecateSnakeCase,
+}
+
+var keepAddrBook bool
+
+func init() {
+	ResetAllCmd.Flags().BoolVar(&keepAddrBook, "keep-addr-book", false, "keep the address book intact")
+}
+
+// ResetPrivValidatorCmd resets the private validator files.
+var ResetPrivValidatorCmd = &cobra.Command{
+	Use:     "unsafe-reset-priv-validator",
+	Aliases: []string{"unsafe_reset_priv_validator"},
+	Short:   "(unsafe) Reset this node's validator to genesis state",
+	Run:     resetPrivValidator,
+	PreRun:  deprecateSnakeCase,
+}
+
+// XXX: this is totally unsafe.
+// it's only suitable for testnets.
+func resetAll(cmd *cobra.Command, args []string) {
+	ResetAll(config.DBDir(), config.P2P.AddrBookFile(), config.PrivValidatorKeyFile(),
+		config.PrivValidatorStateFile(), logger)
+}
+
+// XXX: this is totally unsafe.
+// it's only suitable for testnets.
+func resetPrivValidator(cmd *cobra.Command, args []string) {
+	resetFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile(), logger)
+}
+
+// ResetAll removes address book files plus all data, and resets the privValdiator data.
+// Exported so other CLI tools can use it.
+func ResetAll(dbDir, addrBookFile, privValKeyFile, privValStateFile string, logger log.Logger) {
+	if keepAddrBook {
+		logger.Info("The address book remains intact")
+	} else {
+		removeAddrBook(addrBookFile, logger)
+	}
+	if err := os.RemoveAll(dbDir); err == nil {
+		logger.Info("Removed all blockchain history", "dir", dbDir)
+	} else {
+		logger.Error("Error removing all blockchain history", "dir", dbDir, "err", err)
+	}
+	// recreate the dbDir since the privVal state needs to live there
+	if err := tmos.EnsureDir(dbDir, 0700); err != nil {
+		logger.Error("unable to recreate dbDir", "err", err)
+	}
+	resetFilePV(privValKeyFile, privValStateFile, logger)
+}
+
+func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger) {
+	if _, err := os.Stat(privValKeyFile); err == nil {
+		pv := privval.LoadFilePVEmptyState(privValKeyFile, privValStateFile)
+		pv.Reset()
+		logger.Info("Reset private validator file to genesis state", "keyFile", privValKeyFile,
+			"stateFile", privValStateFile)
+	} else {
+		pv := privval.GenFilePV(privValKeyFile, privValStateFile)
+		pv.Save()
+		logger.Info("Generated private validator file", "keyFile", privValKeyFile,
+			"stateFile", privValStateFile)
+	}
+}
+
+func removeAddrBook(addrBookFile string, logger log.Logger) {
+	if err := os.Remove(addrBookFile); err == nil {
+		logger.Info("Removed existing address book", "file", addrBookFile)
+	} else if !os.IsNotExist(err) {
+		logger.Info("Error removing address book", "file", addrBookFile, "err", err)
+	}
+}

cmd/tendermint/commands/reset_test.go

@@ -1,53 +0,0 @@
-package commands
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/privval"
-)
-
-func Test_ResetAll(t *testing.T) {
-	config := cfg.TestConfig()
-	dir := t.TempDir()
-	config.SetRoot(dir)
-	cfg.EnsureRoot(dir)
-	require.NoError(t, initFilesWithConfig(config))
-	pv := privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
-	pv.LastSignState.Height = 10
-	pv.Save()
-	require.NoError(t, resetAll(config.DBDir(), config.P2P.AddrBookFile(), config.PrivValidatorKeyFile(),
-		config.PrivValidatorStateFile(), logger))
-	require.DirExists(t, config.DBDir())
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "block.db"))
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "state.db"))
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "evidence.db"))
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "tx_index.db"))
-	require.FileExists(t, config.PrivValidatorStateFile())
-	pv = privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
-	require.Equal(t, int64(0), pv.LastSignState.Height)
-}
-
-func Test_ResetState(t *testing.T) {
-	config := cfg.TestConfig()
-	dir := t.TempDir()
-	config.SetRoot(dir)
-	cfg.EnsureRoot(dir)
-	require.NoError(t, initFilesWithConfig(config))
-	pv := privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
-	pv.LastSignState.Height = 10
-	pv.Save()
-	require.NoError(t, resetState(config.DBDir(), logger))
-	require.DirExists(t, config.DBDir())
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "block.db"))
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "state.db"))
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "evidence.db"))
-	require.NoFileExists(t, filepath.Join(config.DBDir(), "tx_index.db"))
-	require.FileExists(t, config.PrivValidatorStateFile())
-	pv = privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
-	// private validator state should still be in tact.
-	require.Equal(t, int64(10), pv.LastSignState.Height)
-}

cmd/tendermint/commands/rollback.go

@@ -2,14 +2,12 @@ package commands
 
 import (
 	"fmt"
-	"path/filepath"
 
 	"github.com/spf13/cobra"
 
 	dbm "github.com/tendermint/tm-db"
 
 	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 )
@@ -45,10 +43,6 @@ func RollbackState(config *cfg.Config) (int64, []byte, error) {
 	if err != nil {
 		return -1, nil, err
 	}
-	defer func() {
-		_ = blockStore.Close()
-		_ = stateStore.Close()
-	}()
 
 	// rollback the last state
 	return state.Rollback(blockStore, stateStore)
@@ -57,10 +51,6 @@ func RollbackState(config *cfg.Config) (int64, []byte, error) {
 func loadStateAndBlockStore(config *cfg.Config) (*store.BlockStore, state.Store, error) {
 	dbType := dbm.BackendType(config.DBBackend)
 
-	if !os.FileExists(filepath.Join(config.DBDir(), "blockstore.db")) {
-		return nil, nil, fmt.Errorf("no blockstore found in %v", config.DBDir())
-	}
-
 	// Get BlockStore
 	blockStoreDB, err := dbm.NewDB("blockstore", dbType, config.DBDir())
 	if err != nil {
@@ -68,10 +58,6 @@ func loadStateAndBlockStore(config *cfg.Config) (*store.BlockStore, state.Store,
 	}
 	blockStore := store.NewBlockStore(blockStoreDB)
 
-	if !os.FileExists(filepath.Join(config.DBDir(), "state.db")) {
-		return nil, nil, fmt.Errorf("no statestore found in %v", config.DBDir())
-	}
-
 	// Get StateStore
 	stateDB, err := dbm.NewDB("state", dbType, config.DBDir())
 	if err != nil {

cmd/tendermint/main.go

@@ -22,14 +22,12 @@ func main() {
 		cmd.ReplayConsoleCmd,
 		cmd.ResetAllCmd,
 		cmd.ResetPrivValidatorCmd,
-		cmd.ResetStateCmd,
 		cmd.ShowValidatorCmd,
 		cmd.TestnetFilesCmd,
 		cmd.ShowNodeIDCmd,
 		cmd.GenNodeKeyCmd,
 		cmd.VersionCmd,
 		cmd.RollbackStateCmd,
-		cmd.CompactGoLevelDBCmd,
 		debug.DebugCmd,
 		cli.NewCompletionCmd(rootCmd, true),
 	)

config/config.go

@@ -23,11 +23,6 @@ const (
 
 	// DefaultLogLevel defines a default log level as INFO.
 	DefaultLogLevel = "info"
-
-	// Mempool versions. V1 is prioritized mempool, v0 is regular mempool.
-	// Default is v0.
-	MempoolV0 = "v0"
-	MempoolV1 = "v1"
 )
 
 // NOTE: Most of the structs & relevant comments + the
@@ -57,9 +52,6 @@ var (
 
 	defaultNodeKeyPath  = filepath.Join(defaultConfigDir, defaultNodeKeyName)
 	defaultAddrBookPath = filepath.Join(defaultConfigDir, defaultAddrBookName)
-
-	minSubscriptionBufferSize     = 100
-	defaultSubscriptionBufferSize = 200
 )
 
 // Config defines the top level configuration for a Tendermint node
@@ -350,29 +342,6 @@ type RPCConfig struct {
 	// to the estimated maximum number of broadcast_tx_commit calls per block.
 	MaxSubscriptionsPerClient int `mapstructure:"max_subscriptions_per_client"`
 
-	// The number of events that can be buffered per subscription before
-	// returning `ErrOutOfCapacity`.
-	SubscriptionBufferSize int `mapstructure:"experimental_subscription_buffer_size"`
-
-	// The maximum number of responses that can be buffered per WebSocket
-	// client. If clients cannot read from the WebSocket endpoint fast enough,
-	// they will be disconnected, so increasing this parameter may reduce the
-	// chances of them being disconnected (but will cause the node to use more
-	// memory).
-	//
-	// Must be at least the same as `SubscriptionBufferSize`, otherwise
-	// connections may be dropped unnecessarily.
-	WebSocketWriteBufferSize int `mapstructure:"experimental_websocket_write_buffer_size"`
-
-	// If a WebSocket client cannot read fast enough, at present we may
-	// silently drop events instead of generating an error or disconnecting the
-	// client.
-	//
-	// Enabling this parameter will cause the WebSocket connection to be closed
-	// instead if it cannot read fast enough, allowing for greater
-	// predictability in subscription behavior.
-	CloseOnSlowClient bool `mapstructure:"experimental_close_on_slow_client"`
-
 	// How long to wait for a tx to be committed during /broadcast_tx_commit
 	// WARNING: Using a value larger than 10s will result in increasing the
 	// global HTTP write timeout, which applies to all connections and endpoints.
@@ -422,9 +391,7 @@ func DefaultRPCConfig() *RPCConfig {
 
 		MaxSubscriptionClients:    100,
 		MaxSubscriptionsPerClient: 5,
-		SubscriptionBufferSize:    defaultSubscriptionBufferSize,
 		TimeoutBroadcastTxCommit:  10 * time.Second,
-		WebSocketWriteBufferSize:  defaultSubscriptionBufferSize,
 
 		MaxBodyBytes:   int64(1000000), // 1MB
 		MaxHeaderBytes: 1 << 20,        // same as the net/http default
@@ -458,18 +425,6 @@ func (cfg *RPCConfig) ValidateBasic() error {
 	if cfg.MaxSubscriptionsPerClient < 0 {
 		return errors.New("max_subscriptions_per_client can't be negative")
 	}
-	if cfg.SubscriptionBufferSize < minSubscriptionBufferSize {
-		return fmt.Errorf(
-			"experimental_subscription_buffer_size must be >= %d",
-			minSubscriptionBufferSize,
-		)
-	}
-	if cfg.WebSocketWriteBufferSize < cfg.SubscriptionBufferSize {
-		return fmt.Errorf(
-			"experimental_websocket_write_buffer_size must be >= experimental_subscription_buffer_size (%d)",
-			cfg.SubscriptionBufferSize,
-		)
-	}
 	if cfg.TimeoutBroadcastTxCommit < 0 {
 		return errors.New("timeout_broadcast_tx_commit can't be negative")
 	}
@@ -681,13 +636,6 @@ func DefaultFuzzConnConfig() *FuzzConnConfig {
 
 // MempoolConfig defines the configuration options for the Tendermint mempool
 type MempoolConfig struct {
-	// Mempool version to use:
-	//  1) "v0" - (default) FIFO mempool.
-	//  2) "v1" - prioritized mempool.
-	// WARNING: There's a known memory leak with the prioritized mempool
-	// that the team are working on. Read more here:
-	// https://github.com/tendermint/tendermint/issues/8775
-	Version   string `mapstructure:"version"`
 	RootDir   string `mapstructure:"home"`
 	Recheck   bool   `mapstructure:"recheck"`
 	Broadcast bool   `mapstructure:"broadcast"`
@@ -711,39 +659,20 @@ type MempoolConfig struct {
 	// Including space needed by encoding (one varint per transaction).
 	// XXX: Unused due to https://github.com/tendermint/tendermint/issues/5796
 	MaxBatchBytes int `mapstructure:"max_batch_bytes"`
-
-	// TTLDuration, if non-zero, defines the maximum amount of time a transaction
-	// can exist for in the mempool.
-	//
-	// Note, if TTLNumBlocks is also defined, a transaction will be removed if it
-	// has existed in the mempool at least TTLNumBlocks number of blocks or if it's
-	// insertion time into the mempool is beyond TTLDuration.
-	TTLDuration time.Duration `mapstructure:"ttl-duration"`
-
-	// TTLNumBlocks, if non-zero, defines the maximum number of blocks a transaction
-	// can exist for in the mempool.
-	//
-	// Note, if TTLDuration is also defined, a transaction will be removed if it
-	// has existed in the mempool at least TTLNumBlocks number of blocks or if
-	// it's insertion time into the mempool is beyond TTLDuration.
-	TTLNumBlocks int64 `mapstructure:"ttl-num-blocks"`
 }
 
 // DefaultMempoolConfig returns a default configuration for the Tendermint mempool
 func DefaultMempoolConfig() *MempoolConfig {
 	return &MempoolConfig{
-		Version:   MempoolV0,
 		Recheck:   true,
 		Broadcast: true,
 		WalPath:   "",
 		// Each signature verification takes .5ms, Size reduced until we implement
 		// ABCI Recheck
-		Size:         5000,
-		MaxTxsBytes:  1024 * 1024 * 1024, // 1GB
-		CacheSize:    10000,
-		MaxTxBytes:   1024 * 1024, // 1MB
-		TTLDuration:  0 * time.Second,
-		TTLNumBlocks: 0,
+		Size:        5000,
+		MaxTxsBytes: 1024 * 1024 * 1024, // 1GB
+		CacheSize:   10000,
+		MaxTxBytes:  1024 * 1024, // 1MB
 	}
 }
 

config/toml.go

@@ -206,33 +206,6 @@ max_subscription_clients = {{ .RPC.MaxSubscriptionClients }}
 # the estimated # maximum number of broadcast_tx_commit calls per block.
 max_subscriptions_per_client = {{ .RPC.MaxSubscriptionsPerClient }}
 
-# Experimental parameter to specify the maximum number of events a node will
-# buffer, per subscription, before returning an error and closing the
-# subscription. Must be set to at least 100, but higher values will accommodate
-# higher event throughput rates (and will use more memory).
-experimental_subscription_buffer_size = {{ .RPC.SubscriptionBufferSize }}
-
-# Experimental parameter to specify the maximum number of RPC responses that
-# can be buffered per WebSocket client. If clients cannot read from the
-# WebSocket endpoint fast enough, they will be disconnected, so increasing this
-# parameter may reduce the chances of them being disconnected (but will cause
-# the node to use more memory).
-#
-# Must be at least the same as "experimental_subscription_buffer_size",
-# otherwise connections could be dropped unnecessarily. This value should
-# ideally be somewhat higher than "experimental_subscription_buffer_size" to
-# accommodate non-subscription-related RPC responses.
-experimental_websocket_write_buffer_size = {{ .RPC.WebSocketWriteBufferSize }}
-
-# If a WebSocket client cannot read fast enough, at present we may
-# silently drop events instead of generating an error or disconnecting the
-# client.
-#
-# Enabling this experimental parameter will cause the WebSocket connection to
-# be closed instead if it cannot read fast enough, allowing for greater
-# predictability in subscription behavior.
-experimental_close_on_slow_client = {{ .RPC.CloseOnSlowClient }}
-
 # How long to wait for a tx to be committed during /broadcast_tx_commit.
 # WARNING: Using a value larger than 10s will result in increasing the
 # global HTTP write timeout, which applies to all connections and endpoints.
@@ -342,11 +315,6 @@ dial_timeout = "{{ .P2P.DialTimeout }}"
 #######################################################
 [mempool]
 
-# Mempool version to use:
-#   1) "v0" - (default) FIFO mempool.
-#   2) "v1" - prioritized mempool.
-version = "{{ .Mempool.Version }}"
-
 recheck = {{ .Mempool.Recheck }}
 broadcast = {{ .Mempool.Broadcast }}
 wal_dir = "{{ js .Mempool.WalPath }}"
@@ -376,22 +344,6 @@ max_tx_bytes = {{ .Mempool.MaxTxBytes }}
 # XXX: Unused due to https://github.com/tendermint/tendermint/issues/5796
 max_batch_bytes = {{ .Mempool.MaxBatchBytes }}
 
-# ttl-duration, if non-zero, defines the maximum amount of time a transaction
-# can exist for in the mempool.
-#
-# Note, if ttl-num-blocks is also defined, a transaction will be removed if it
-# has existed in the mempool at least ttl-num-blocks number of blocks or if it's
-# insertion time into the mempool is beyond ttl-duration.
-ttl-duration = "{{ .Mempool.TTLDuration }}"
-
-# ttl-num-blocks, if non-zero, defines the maximum number of blocks a transaction
-# can exist for in the mempool.
-#
-# Note, if ttl-duration is also defined, a transaction will be removed if it
-# has existed in the mempool at least ttl-num-blocks number of blocks or if
-# it's insertion time into the mempool is beyond ttl-duration.
-ttl-num-blocks = {{ .Mempool.TTLNumBlocks }}
-
 #######################################################
 ###         State Sync Configuration Options        ###
 #######################################################
@@ -494,14 +446,8 @@ peer_query_maj23_sleep_duration = "{{ .Consensus.PeerQueryMaj23SleepDuration }}"
 #   1) "null"
 #   2) "kv" (default) - the simplest possible indexer, backed by key-value storage (defaults to levelDB; see DBBackend).
 # 		- When "kv" is chosen "tx.height" and "tx.hash" will always be indexed.
-#   3) "psql" - the indexer services backed by PostgreSQL.
-# When "kv" or "psql" is chosen "tx.height" and "tx.hash" will always be indexed.
 indexer = "{{ .TxIndex.Indexer }}"
 
-# The PostgreSQL connection configuration, the connection format:
-#   postgresql://<user>:<password>@<host>:<port>/<db>?<opts>
-psql-conn = "{{ .TxIndex.PsqlConn }}"
-
 #######################################################
 ###       Instrumentation Configuration Options     ###
 #######################################################

consensus/byzantine_test.go

@@ -21,10 +21,6 @@ import (
 	"github.com/tendermint/tendermint/libs/service"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
 	mempl "github.com/tendermint/tendermint/mempool"
-
-	cfg "github.com/tendermint/tendermint/config"
-	mempoolv0 "github.com/tendermint/tendermint/mempool/v0"
-	mempoolv1 "github.com/tendermint/tendermint/mempool/v1"
 	"github.com/tendermint/tendermint/p2p"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	sm "github.com/tendermint/tendermint/state"
@@ -62,31 +58,14 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		blockDB := dbm.NewMemDB()
 		blockStore := store.NewBlockStore(blockDB)
 
-		mtx := new(tmsync.Mutex)
 		// one for mempool, one for consensus
+		mtx := new(tmsync.Mutex)
+		proxyAppConnMem := abcicli.NewLocalClient(mtx, app)
 		proxyAppConnCon := abcicli.NewLocalClient(mtx, app)
-		proxyAppConnConMem := abcicli.NewLocalClient(mtx, app)
 
 		// Make Mempool
-		var mempool mempl.Mempool
-
-		switch thisConfig.Mempool.Version {
-		case cfg.MempoolV0:
-			mempool = mempoolv0.NewCListMempool(config.Mempool,
-				proxyAppConnConMem,
-				state.LastBlockHeight,
-				mempoolv0.WithPreCheck(sm.TxPreCheck(state)),
-				mempoolv0.WithPostCheck(sm.TxPostCheck(state)))
-		case cfg.MempoolV1:
-			mempool = mempoolv1.NewTxMempool(logger,
-				config.Mempool,
-				proxyAppConnConMem,
-				state.LastBlockHeight,
-				mempoolv1.WithPreCheck(sm.TxPreCheck(state)),
-				mempoolv1.WithPostCheck(sm.TxPostCheck(state)),
-			)
-		}
-
+		mempool := mempl.NewCListMempool(thisConfig.Mempool, proxyAppConnMem, 0)
+		mempool.SetLogger(log.TestingLogger().With("module", "mempool"))
 		if thisConfig.Consensus.WaitForTxs() {
 			mempool.EnableTxsAvailable()
 		}
@@ -211,11 +190,9 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		}
 		proposerAddr := lazyProposer.privValidatorPubKey.Address()
 
-		block, err := lazyProposer.blockExec.CreateProposalBlock(
-			lazyProposer.Height, lazyProposer.state, commit, proposerAddr, nil)
-		require.NoError(t, err)
-		blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
-		require.NoError(t, err)
+		block, blockParts := lazyProposer.blockExec.CreateProposalBlock(
+			lazyProposer.Height, lazyProposer.state, commit, proposerAddr,
+		)
 
 		// Flush the WAL. Otherwise, we may not recompute the same proposal to sign,
 		// and the privValidator will refuse to sign anything.
@@ -463,10 +440,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 	// Avoid sending on internalMsgQueue and running consensus state.
 
 	// Create a new proposal block from state/txs from the mempool.
-	block1, err := cs.createProposalBlock()
-	require.NoError(t, err)
-	blockParts1, err := block1.MakePartSet(types.BlockPartSizeBytes)
-	require.NoError(t, err)
+	block1, blockParts1 := cs.createProposalBlock()
 	polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartSetHeader: blockParts1.Header()}
 	proposal1 := types.NewProposal(height, round, polRound, propBlockID)
 	p1 := proposal1.ToProto()
@@ -480,10 +454,7 @@ func byzantineDecideProposalFunc(t *testing.T, height int64, round int32, cs *St
 	deliverTxsRange(cs, 0, 1)
 
 	// Create a new proposal block from state/txs from the mempool.
-	block2, err := cs.createProposalBlock()
-	require.NoError(t, err)
-	blockParts2, err := block2.MakePartSet(types.BlockPartSizeBytes)
-	require.NoError(t, err)
+	block2, blockParts2 := cs.createProposalBlock()
 	polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartSetHeader: blockParts2.Header()}
 	proposal2 := types.NewProposal(height, round, polRound, propBlockID)
 	p2 := proposal2.ToProto()

consensus/common_test.go

@@ -12,8 +12,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/go-kit/log/term"
-	"github.com/stretchr/testify/assert"
+	"github.com/go-kit/kit/log/term"
 	"github.com/stretchr/testify/require"
 
 	"path"
@@ -32,8 +31,6 @@ import (
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
 	mempl "github.com/tendermint/tendermint/mempool"
-	mempoolv0 "github.com/tendermint/tendermint/mempool/v0"
-	mempoolv1 "github.com/tendermint/tendermint/mempool/v1"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/privval"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
@@ -202,17 +199,13 @@ func startTestRound(cs *State, height int64, round int32) {
 
 // Create proposal block from cs1 but sign it with vs.
 func decideProposal(
-	t *testing.T,
 	cs1 *State,
 	vs *validatorStub,
 	height int64,
 	round int32,
 ) (proposal *types.Proposal, block *types.Block) {
 	cs1.mtx.Lock()
-	block, err := cs1.createProposalBlock()
-	require.NoError(t, err)
-	blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
-	require.NoError(t, err)
+	block, blockParts := cs1.createProposalBlock()
 	validRound := cs1.ValidRound
 	chainID := cs1.state.ChainID
 	cs1.mtx.Unlock()
@@ -397,34 +390,12 @@ func newStateWithConfigAndBlockStore(
 
 	// one for mempool, one for consensus
 	mtx := new(tmsync.Mutex)
-
+	proxyAppConnMem := abcicli.NewLocalClient(mtx, app)
 	proxyAppConnCon := abcicli.NewLocalClient(mtx, app)
-	proxyAppConnConMem := abcicli.NewLocalClient(mtx, app)
-	// Make Mempool
-	memplMetrics := mempl.NopMetrics()
 
 	// Make Mempool
-	var mempool mempl.Mempool
-
-	switch config.Mempool.Version {
-	case cfg.MempoolV0:
-		mempool = mempoolv0.NewCListMempool(config.Mempool,
-			proxyAppConnConMem,
-			state.LastBlockHeight,
-			mempoolv0.WithMetrics(memplMetrics),
-			mempoolv0.WithPreCheck(sm.TxPreCheck(state)),
-			mempoolv0.WithPostCheck(sm.TxPostCheck(state)))
-	case cfg.MempoolV1:
-		logger := consensusLogger()
-		mempool = mempoolv1.NewTxMempool(logger,
-			config.Mempool,
-			proxyAppConnConMem,
-			state.LastBlockHeight,
-			mempoolv1.WithMetrics(memplMetrics),
-			mempoolv1.WithPreCheck(sm.TxPreCheck(state)),
-			mempoolv1.WithPostCheck(sm.TxPostCheck(state)),
-		)
-	}
+	mempool := mempl.NewCListMempool(thisConfig.Mempool, proxyAppConnMem, 0)
+	mempool.SetLogger(log.TestingLogger().With("module", "mempool"))
 	if thisConfig.Consensus.WaitForTxs() {
 		mempool.EnableTxsAvailable()
 	}
@@ -463,16 +434,12 @@ func loadPrivValidator(config *cfg.Config) *privval.FilePV {
 }
 
 func randState(nValidators int) (*State, []*validatorStub) {
-	return randStateWithApp(nValidators, counter.NewApplication(true))
-}
-
-func randStateWithApp(nValidators int, app abci.Application) (*State, []*validatorStub) {
 	// Get State
 	state, privVals := randGenesisState(nValidators, false, 10)
 
 	vss := make([]*validatorStub, nValidators)
 
-	cs := newState(state, privVals[0], app)
+	cs := newState(state, privVals[0], counter.NewApplication(true))
 
 	for i := 0; i < nValidators; i++ {
 		vss[i] = newValidatorStub(privVals[i], int32(i))
@@ -687,33 +654,6 @@ func ensureVote(voteCh <-chan tmpubsub.Message, height int64, round int32,
 	}
 }
 
-func ensurePrevoteMatch(t *testing.T, voteCh <-chan tmpubsub.Message, height int64, round int32, hash []byte) {
-	t.Helper()
-	ensureVoteMatch(t, voteCh, height, round, hash, tmproto.PrevoteType)
-}
-
-func ensureVoteMatch(t *testing.T, voteCh <-chan tmpubsub.Message, height int64, round int32, hash []byte, voteType tmproto.SignedMsgType) {
-	t.Helper()
-	select {
-	case <-time.After(ensureTimeout):
-		t.Fatal("Timeout expired while waiting for NewVote event")
-	case msg := <-voteCh:
-		voteEvent, ok := msg.Data().(types.EventDataVote)
-		require.True(t, ok, "expected a EventDataVote, got %T. Wrong subscription channel?",
-			msg.Data())
-
-		vote := voteEvent.Vote
-		assert.Equal(t, height, vote.Height, "expected height %d, but got %d", height, vote.Height)
-		assert.Equal(t, round, vote.Round, "expected round %d, but got %d", round, vote.Round)
-		assert.Equal(t, voteType, vote.Type, "expected type %s, but got %s", voteType, vote.Type)
-		if hash == nil {
-			require.Nil(t, vote.BlockID.Hash, "Expected prevote to be for nil, got %X", vote.BlockID.Hash)
-		} else {
-			require.True(t, bytes.Equal(vote.BlockID.Hash, hash), "Expected prevote to be for %X, got %X", hash, vote.BlockID.Hash)
-		}
-	}
-}
-
 func ensurePrecommitTimeout(ch <-chan tmpubsub.Message) {
 	select {
 	case <-time.After(ensureTimeout):

consensus/mempool_test.go

@@ -256,26 +256,3 @@ func (app *CounterApplication) Commit() abci.ResponseCommit {
 	binary.BigEndian.PutUint64(hash, uint64(app.txCount))
 	return abci.ResponseCommit{Data: hash}
 }
-
-func (app *CounterApplication) PrepareProposal(
-	req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
-
-	trs := make([]*abci.TxRecord, 0, len(req.Txs))
-	var totalBytes int64
-	for _, tx := range req.Txs {
-		totalBytes += int64(len(tx))
-		if totalBytes > req.MaxTxBytes {
-			break
-		}
-		trs = append(trs, &abci.TxRecord{
-			Action: abci.TxRecord_UNMODIFIED,
-			Tx:     tx,
-		})
-	}
-	return abci.ResponsePrepareProposal{TxRecords: trs}
-}
-
-func (app *CounterApplication) ProcessProposal(
-	req abci.RequestProcessProposal) abci.ResponseProcessProposal {
-	return abci.ResponseProcessProposal{Status: abci.ResponseProcessProposal_ACCEPT}
-}

consensus/metrics.go

@@ -60,22 +60,6 @@ type Metrics struct {
 
 	// Number of blockparts transmitted by peer.
 	BlockParts metrics.Counter
-
-	// QuroumPrevoteMessageDelay is the interval in seconds between the proposal
-	// timestamp and the timestamp of the earliest prevote that achieved a quorum
-	// during the prevote step.
-	//
-	// To compute it, sum the voting power over each prevote received, in increasing
-	// order of timestamp. The timestamp of the first prevote to increase the sum to
-	// be above 2/3 of the total voting power of the network defines the endpoint
-	// the endpoint of the interval. Subtract the proposal timestamp from this endpoint
-	// to obtain the quorum delay.
-	QuorumPrevoteMessageDelay metrics.Gauge
-
-	// FullPrevoteMessageDelay is the interval in seconds between the proposal
-	// timestamp and the timestamp of the latest prevote in a round where 100%
-	// of the voting power on the network issued prevotes.
-	FullPrevoteMessageDelay metrics.Gauge
 }
 
 // PrometheusMetrics returns Metrics build using Prometheus client library.
@@ -202,20 +186,6 @@ func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics {
 			Name:      "block_parts",
 			Help:      "Number of blockparts transmitted by peer.",
 		}, append(labels, "peer_id")).With(labelsAndValues...),
-		QuorumPrevoteMessageDelay: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "quorum_prevote_message_delay",
-			Help: "Difference in seconds between the proposal timestamp and the timestamp " +
-				"of the latest prevote that achieved a quorum in the prevote step.",
-		}, labels).With(labelsAndValues...),
-		FullPrevoteMessageDelay: prometheus.NewGaugeFrom(stdprometheus.GaugeOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "full_prevote_message_delay",
-			Help: "Difference in seconds between the proposal timestamp and the timestamp " +
-				"of the latest prevote that achieved 100% of the voting power in the prevote step.",
-		}, labels).With(labelsAndValues...),
 	}
 }
 
@@ -239,14 +209,12 @@ func NopMetrics() *Metrics {
 
 		BlockIntervalSeconds: discard.NewHistogram(),
 
-		NumTxs:                    discard.NewGauge(),
-		BlockSizeBytes:            discard.NewGauge(),
-		TotalTxs:                  discard.NewGauge(),
-		CommittedHeight:           discard.NewGauge(),
-		FastSyncing:               discard.NewGauge(),
-		StateSyncing:              discard.NewGauge(),
-		BlockParts:                discard.NewCounter(),
-		QuorumPrevoteMessageDelay: discard.NewGauge(),
-		FullPrevoteMessageDelay:   discard.NewGauge(),
+		NumTxs:          discard.NewGauge(),
+		BlockSizeBytes:  discard.NewGauge(),
+		TotalTxs:        discard.NewGauge(),
+		CommittedHeight: discard.NewGauge(),
+		FastSyncing:     discard.NewGauge(),
+		StateSyncing:    discard.NewGauge(),
+		BlockParts:      discard.NewCounter(),
 	}
 }

consensus/reactor.go

@@ -46,7 +46,6 @@ type Reactor struct {
 	mtx      tmsync.RWMutex
 	waitSync bool
 	eventBus *types.EventBus
-	rs       *cstypes.RoundState
 
 	Metrics *Metrics
 }
@@ -59,7 +58,6 @@ func NewReactor(consensusState *State, waitSync bool, options ...ReactorOption)
 	conR := &Reactor{
 		conS:     consensusState,
 		waitSync: waitSync,
-		rs:       consensusState.GetRoundState(),
 		Metrics:  NopMetrics(),
 	}
 	conR.BaseReactor = *p2p.NewBaseReactor("Consensus", conR)
@@ -80,7 +78,6 @@ func (conR *Reactor) OnStart() error {
 	go conR.peerStatsRoutine()
 
 	conR.subscribeToBroadcastEvents()
-	go conR.updateRoundStateRoutine()
 
 	if !conR.WaitSync() {
 		err := conR.conS.Start()
@@ -485,31 +482,11 @@ func makeRoundStepMessage(rs *cstypes.RoundState) (nrsMsg *NewRoundStepMessage)
 }
 
 func (conR *Reactor) sendNewRoundStepMessage(peer p2p.Peer) {
-	rs := conR.getRoundState()
+	rs := conR.conS.GetRoundState()
 	nrsMsg := makeRoundStepMessage(rs)
 	peer.Send(StateChannel, MustEncode(nrsMsg))
 }
 
-func (conR *Reactor) updateRoundStateRoutine() {
-	t := time.NewTicker(100 * time.Microsecond)
-	defer t.Stop()
-	for range t.C {
-		if !conR.IsRunning() {
-			return
-		}
-		rs := conR.conS.GetRoundState()
-		conR.mtx.Lock()
-		conR.rs = rs
-		conR.mtx.Unlock()
-	}
-}
-
-func (conR *Reactor) getRoundState() *cstypes.RoundState {
-	conR.mtx.RLock()
-	defer conR.mtx.RUnlock()
-	return conR.rs
-}
-
 func (conR *Reactor) gossipDataRoutine(peer p2p.Peer, ps *PeerState) {
 	logger := conR.Logger.With("peer", peer)
 
@@ -517,9 +494,10 @@ OUTER_LOOP:
 	for {
 		// Manage disconnects from self or peer.
 		if !peer.IsRunning() || !conR.IsRunning() {
+			logger.Info("Stopping gossipDataRoutine for peer")
 			return
 		}
-		rs := conR.getRoundState()
+		rs := conR.conS.GetRoundState()
 		prs := ps.GetRoundState()
 
 		// Send proposal Block parts?
@@ -660,9 +638,10 @@ OUTER_LOOP:
 	for {
 		// Manage disconnects from self or peer.
 		if !peer.IsRunning() || !conR.IsRunning() {
+			logger.Info("Stopping gossipVotesRoutine for peer")
 			return
 		}
-		rs := conR.getRoundState()
+		rs := conR.conS.GetRoundState()
 		prs := ps.GetRoundState()
 
 		switch sleeping {
@@ -784,17 +763,19 @@ func (conR *Reactor) gossipVotesForHeight(
 // NOTE: `queryMaj23Routine` has a simple crude design since it only comes
 // into play for liveness when there's a signature DDoS attack happening.
 func (conR *Reactor) queryMaj23Routine(peer p2p.Peer, ps *PeerState) {
+	logger := conR.Logger.With("peer", peer)
 
 OUTER_LOOP:
 	for {
 		// Manage disconnects from self or peer.
 		if !peer.IsRunning() || !conR.IsRunning() {
+			logger.Info("Stopping queryMaj23Routine for peer")
 			return
 		}
 
 		// Maybe send Height/Round/Prevotes
 		{
-			rs := conR.getRoundState()
+			rs := conR.conS.GetRoundState()
 			prs := ps.GetRoundState()
 			if rs.Height == prs.Height {
 				if maj23, ok := rs.Votes.Prevotes(prs.Round).TwoThirdsMajority(); ok {
@@ -811,7 +792,7 @@ OUTER_LOOP:
 
 		// Maybe send Height/Round/Precommits
 		{
-			rs := conR.getRoundState()
+			rs := conR.conS.GetRoundState()
 			prs := ps.GetRoundState()
 			if rs.Height == prs.Height {
 				if maj23, ok := rs.Votes.Precommits(prs.Round).TwoThirdsMajority(); ok {
@@ -828,7 +809,7 @@ OUTER_LOOP:
 
 		// Maybe send Height/Round/ProposalPOL
 		{
-			rs := conR.getRoundState()
+			rs := conR.conS.GetRoundState()
 			prs := ps.GetRoundState()
 			if rs.Height == prs.Height && prs.ProposalPOLRound >= 0 {
 				if maj23, ok := rs.Votes.Prevotes(prs.ProposalPOLRound).TwoThirdsMajority(); ok {
@@ -1265,12 +1246,12 @@ func (ps *PeerState) SetHasVote(vote *types.Vote) {
 }
 
 func (ps *PeerState) setHasVote(height int64, round int32, voteType tmproto.SignedMsgType, index int32) {
-	ps.logger.Debug("setHasVote",
+	logger := ps.logger.With(
 		"peerH/R",
-		log.NewLazySprintf("%d/%d", ps.PRS.Height, ps.PRS.Round),
+		fmt.Sprintf("%d/%d", ps.PRS.Height, ps.PRS.Round),
 		"H/R",
-		log.NewLazySprintf("%d/%d", height, round),
-		"type", voteType, "index", index)
+		fmt.Sprintf("%d/%d", height, round))
+	logger.Debug("setHasVote", "type", voteType, "index", index)
 
 	// NOTE: some may be nil BitArrays -> no side effects.
 	psVotes := ps.getVoteBitArray(height, round, voteType)
@@ -1495,7 +1476,7 @@ func (m *NewRoundStepMessage) ValidateHeight(initialHeight int64) error {
 			m.LastCommitRound, initialHeight)
 	}
 	if m.Height > initialHeight && m.LastCommitRound < 0 {
-		return fmt.Errorf("LastCommitRound can only be negative for initial height %v",
+		return fmt.Errorf("LastCommitRound can only be negative for initial height %v", // nolint
 			initialHeight)
 	}
 	return nil

consensus/reactor_test.go

@@ -29,8 +29,6 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmsync "github.com/tendermint/tendermint/libs/sync"
 	mempl "github.com/tendermint/tendermint/mempool"
-	mempoolv0 "github.com/tendermint/tendermint/mempool/v0"
-	mempoolv1 "github.com/tendermint/tendermint/mempool/v1"
 	"github.com/tendermint/tendermint/p2p"
 	p2pmock "github.com/tendermint/tendermint/p2p/mock"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
@@ -154,33 +152,14 @@ func TestReactorWithEvidence(t *testing.T) {
 		blockDB := dbm.NewMemDB()
 		blockStore := store.NewBlockStore(blockDB)
 
-		mtx := new(tmsync.Mutex)
-		memplMetrics := mempl.NopMetrics()
 		// one for mempool, one for consensus
+		mtx := new(tmsync.Mutex)
+		proxyAppConnMem := abcicli.NewLocalClient(mtx, app)
 		proxyAppConnCon := abcicli.NewLocalClient(mtx, app)
-		proxyAppConnConMem := abcicli.NewLocalClient(mtx, app)
 
 		// Make Mempool
-		var mempool mempl.Mempool
-
-		switch config.Mempool.Version {
-		case cfg.MempoolV0:
-			mempool = mempoolv0.NewCListMempool(config.Mempool,
-				proxyAppConnConMem,
-				state.LastBlockHeight,
-				mempoolv0.WithMetrics(memplMetrics),
-				mempoolv0.WithPreCheck(sm.TxPreCheck(state)),
-				mempoolv0.WithPostCheck(sm.TxPostCheck(state)))
-		case cfg.MempoolV1:
-			mempool = mempoolv1.NewTxMempool(logger,
-				config.Mempool,
-				proxyAppConnConMem,
-				state.LastBlockHeight,
-				mempoolv1.WithMetrics(memplMetrics),
-				mempoolv1.WithPreCheck(sm.TxPreCheck(state)),
-				mempoolv1.WithPostCheck(sm.TxPostCheck(state)),
-			)
-		}
+		mempool := mempl.NewCListMempool(thisConfig.Mempool, proxyAppConnMem, 0)
+		mempool.SetLogger(log.TestingLogger().With("module", "mempool"))
 		if thisConfig.Consensus.WaitForTxs() {
 			mempool.EnableTxsAvailable()
 		}