Merge branch 'feature/abci++ppp' into cal/process_proposal

2026-08-16 04:06:12 +00:00 · 2022-08-06 19:39:53 +02:00
parent b54253cada b2409b3345
commit 8188ad3f90
149 changed files with 4040 additions and 2473 deletions
@@ -1,168 +0,0 @@
-version: 2.1
-
-executors:
-  golang:
-    docker:
-      - image: tendermintdev/docker-tendermint-build
-    working_directory: /go/src/github.com/tendermint/tendermint
-    environment:
-      GOBIN: /tmp/bin
-  release:
-    machine: true
-  docs:
-    docker:
-      - image: tendermintdev/docker-website-deployment
-    environment:
-      AWS_REGION: us-east-1
-
-commands:
-  run_test:
-    parameters:
-      script_path:
-        type: string
-    steps:
-      - attach_workspace:
-          at: /tmp/bin
-      - restore_cache:
-          name: "Restore source code cache"
-          keys:
-            - go-src-v1-{{ .Revision }}
-      - checkout
-      - restore_cache:
-          name: "Restore go modules cache"
-          keys:
-            - go-mod-v1-{{ checksum "go.sum" }}
-      - run:
-          name: "Running test"
-          command: |
-            bash << parameters.script_path >>
-jobs:
-  setup_dependencies:
-    executor: golang
-    steps:
-      - checkout
-      - restore_cache:
-          name: "Restore go modules cache"
-          keys:
-            - go-mod-v1-{{ checksum "go.sum" }}
-      - run:
-          command: |
-            mkdir -p /tmp/bin
-      - run:
-          name: Cache go modules
-          command: make go-mod-cache
-      - run:
-          name: tools
-          command: make tools
-      - run:
-          name: "Build binaries"
-          command: make install install_abci
-      - save_cache:
-          name: "Save go modules cache"
-          key: go-mod-v1-{{ checksum "go.sum" }}
-          paths:
-            - "/go/pkg/mod"
-      - save_cache:
-          name: "Save source code cache"
-          key: go-src-v1-{{ .Revision }}
-          paths:
-            - ".git"
-      - persist_to_workspace:
-          root: "/tmp/bin"
-          paths:
-            - "."
-
-  deploy_docs:
-    executor: docs
-    steps:
-      - checkout
-      - run:
-          name: "Pull versions"
-          command: git fetch origin v0.32 v0.33
-      - run:
-          name: "Build docs"
-          command: make build-docs
-      - run:
-          name: "Sync to S3"
-          command: make sync-docs
-
-  prepare_build:
-    executor: golang
-    steps:
-      - restore_cache:
-          name: "Restore source code cache"
-          keys:
-            - go-src-v1-{{ .Revision }}
-      - checkout
-      - run:
-          name: Get next release number
-          command: |
-            export LAST_TAG="`git describe --tags --abbrev=0 --match "${CIRCLE_BRANCH}.*"`"
-            echo "Last tag: ${LAST_TAG}"
-            if [ -z "${LAST_TAG}" ]; then
-              export LAST_TAG="${CIRCLE_BRANCH}"
-              echo "Last tag not found. Possibly fresh branch or feature branch. Setting ${LAST_TAG} as tag."
-            fi
-            export NEXT_TAG="`python -u scripts/release_management/bump-semver.py --version "${LAST_TAG}"`"
-            echo "Next tag: ${NEXT_TAG}"
-            echo "export CIRCLE_TAG=\"${NEXT_TAG}\"" > release-version.source
-      - run:
-          name: Build dependencies
-          command: make tools
-      - persist_to_workspace:
-          root: .
-          paths:
-            - "release-version.source"
-      - save_cache:
-          key: v2-release-deps-{{ checksum "go.sum" }}
-          paths:
-            - "/go/pkg/mod"
-
-  # # Test RPC implementation against the swagger documented specs
-  # contract_tests:
-  #   working_directory: /home/circleci/.go_workspace/src/github.com/tendermint/tendermint
-  #   machine:
-  #     image: circleci/classic:latest
-  #   environment:
-  #     GOBIN: /home/circleci/.go_workspace/bin
-  #     GOPATH: /home/circleci/.go_workspace/
-  #     GOOS: linux
-  #     GOARCH: amd64
-  #   parallelism: 1
-  #   steps:
-  #     - checkout
-  #     - run:
-  #         name: Test RPC endpoints against swagger documentation
-  #         command: |
-  #           set -x
-  #           export PATH=~/.local/bin:$PATH
-  #           # install node and dredd
-  #           ./scripts/get_nodejs.sh
-  #           # build the binaries with a proper version of Go
-  #           docker run --rm -v "$PWD":/go/src/github.com/tendermint/tendermint -w /go/src/github.com/tendermint/tendermint golang make build-linux build-contract-tests-hooks
-  #           # This docker image works with go 1.7, we can install here the hook handler that contract-tests is going to use
-  #           go get github.com/snikch/goodman/cmd/goodman
-  #           make contract-tests
-
-workflows:
-  version: 2
-  docs:
-    jobs:
-      - deploy_docs:
-          context: tendermint-docs
-          filters:
-            branches:
-              only:
-                - master
-            tags:
-              only:
-                - /^v.*/
-      - deploy_docs:
-          context: tendermint-docs-staging
-          filters:
-            branches:
-              only:
-                - docs-staging
-      # - contract_tests:
-      #     requires:
-      #       - setup_dependencies
@@ -7,4 +7,6 @@
 # global owners are only requested if there isn't a more specific
 # codeowner specified below. For this reason, the global codeowners
 # are often repeated in package-level definitions.
-*      @ebuchman @cmwaters @tychoish @williambanfield @creachadair
+*     @ebuchman @tendermint/tendermint-engineering
+
+/spec @ebuchman @tendermint/tendermint-research @tendermint/tendermint-engineering
@@ -1,13 +1,18 @@
 ---
-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.

-Be ready for followup questions, and please respond in a timely
-manner. We might ask you to provide additional logs and data (tendermint & app).
+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).
+
 -->

 **Tendermint version** (use `tendermint version` or `git rev-parse --verify HEAD` if installed from source):
@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Ask a question
+    url: https://github.com/tendermint/tendermint/discussions
+    about: Please ask and answer questions here
@@ -1,5 +1,5 @@
 ---
-name: Feature Request
+name: Feature request
 about: Create a proposal to request a feature

 ---
@@ -25,12 +25,3 @@ 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
@@ -0,0 +1,28 @@
+---
+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 -->
@@ -1,7 +1,32 @@
-## Description
+<!--

-_Please add a description of the changes that this PR introduces and the files that
-are the most critical to review._ 
+Please add a 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).

-Closes: #XXX
+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

@@ -1,16 +0,0 @@
-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:   
@@ -0,0 +1,25 @@
+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"
@@ -0,0 +1,51 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: weekly
+    target-branch: "main"
+    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
+    open-pull-requests-limit: 10
+
+  ###################################
+  ##
+  ## Update All Go Dependencies
+
+  - package-ecosystem: gomod
+    directory: "/"
+    schedule:
+      interval: weekly
+    target-branch: "main"
+    open-pull-requests-limit: 10
+    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
@@ -0,0 +1,6 @@
+<!--
+
+If you want to ask a general question, please create a new discussion instead of
+an issue: https://github.com/tendermint/tendermint/discussions
+
+-->
@@ -0,0 +1,15 @@
+# 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
@@ -0,0 +1,9 @@
+---
+# 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
@@ -1,13 +1,13 @@
 queue_rules:
  - name: default
    conditions:
-      - base=v0.34.x
+      - base=main
      - label=S:automerge

 pull_request_rules:
-  - name: Automerge to v0.34.x
+  - name: Automerge to main
    conditions:
-      - base=v0.34.x
+      - base=main
      - label=S:automerge
    actions:
      queue:
@@ -17,3 +17,11 @@ pull_request_rules:
          {{ 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
@@ -0,0 +1,82 @@
+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 != ''"
@@ -1,123 +0,0 @@
-name: Test Coverage
-on:
-  pull_request:
-  push:
-    branches:
-      - master
-      - release/**
-
-jobs:
-  split-test-files:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Create a file with all the pkgs
-        run: go list ./... > pkgs.txt
-      - name: Split pkgs into 4 files
-        run: split -d -n l/4 pkgs.txt pkgs.txt.part.
-      # cache multiple
-      - uses: actions/upload-artifact@v3
-        with:
-          name: "${{ github.sha }}-00"
-          path: ./pkgs.txt.part.00
-      - uses: actions/upload-artifact@v3
-        with:
-          name: "${{ github.sha }}-01"
-          path: ./pkgs.txt.part.01
-      - uses: actions/upload-artifact@v3
-        with:
-          name: "${{ github.sha }}-02"
-          path: ./pkgs.txt.part.02
-      - uses: actions/upload-artifact@v3
-        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@v3
-        with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        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@v3
-        with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - uses: actions/download-artifact@v3
-        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@v3
-        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@v3
-      - uses: technote-space/get-diff-action@v6
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - uses: actions/download-artifact@v3
-        with:
-          name: "${{ github.sha }}-00-coverage"
-        if: env.GIT_DIFF
-      - uses: actions/download-artifact@v3
-        with:
-          name: "${{ github.sha }}-01-coverage"
-        if: env.GIT_DIFF
-      - uses: actions/download-artifact@v3
-        with:
-          name: "${{ github.sha }}-02-coverage"
-        if: env.GIT_DIFF
-      - uses: actions/download-artifact@v3
-        with:
-          name: "${{ github.sha }}-03-coverage"
-        if: env.GIT_DIFF
-      - run: |
-          cat ./*profile.out | grep -v "mode: atomic" >> coverage.txt
-        if: env.GIT_DIFF
-      - uses: codecov/codecov-action@v3
-        with:
-          file: ./coverage.txt
-        if: env.GIT_DIFF
@@ -1,14 +1,13 @@
-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
+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
 on:
-  pull_request:
  push:
    branches:
-      - master
+      - main
    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:
@@ -39,18 +38,18 @@ jobs:
        with:
          platforms: all

-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+      - name: Set up Docker Build
+        uses: docker/setup-buildx-action@v2.0.0

      - name: Login to DockerHub
        if: ${{ github.event_name != 'pull_request' }}
-        uses: docker/login-action@v2
+        uses: docker/login-action@v2.0.0
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Publish to Docker Hub
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v3.1.0
        with:
          context: .
          file: ./DOCKER/Dockerfile
@@ -0,0 +1,62 @@
+# 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
@@ -0,0 +1,21 @@
+# 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
@@ -1,4 +1,5 @@
-# Manually run randomly generated E2E testnets (as nightly).
+# Runs randomly generated E2E testnets nightly on main
+# manually run e2e tests
 name: e2e-manual
 on:
  workflow_dispatch:
@@ -28,7 +29,7 @@ jobs:
      - name: Generate testnets
        working-directory: test/e2e
        # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 4 -d networks/nightly/
+        run: ./build/generator -g 5 -d networks/nightly/

      - name: Run ${{ matrix.p2p }} p2p testnets
        working-directory: test/e2e
@@ -1,12 +1,10 @@
-# Runs randomly generated E2E testnets nightly
-# on the 0.34.x release branch
+# Runs randomly generated E2E testnets nightly on the 0.34.x branch.

-# !! If you change something in this file, you probably want
-# to update the e2e-nightly-master workflow as well!
+# !! This file should be kept in sync with the e2e-nightly-main.yml file,
+# modulo changes to the version labels.

 name: e2e-nightly-34x
 on:
-  workflow_dispatch: # allow running workflow manually, in theory
  schedule:
    - cron: '0 2 * * *'

@@ -17,13 +15,13 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        group: ['00', '01', '02', '03']
+        group: ['00', '01', '02', '03', "04"]
    runs-on: ubuntu-latest
    timeout-minutes: 60
    steps:
      - uses: actions/setup-go@v3
        with:
-          go-version: '^1.15.4'
+          go-version: '1.17'

      - uses: actions/checkout@v3
        with:
@@ -37,7 +35,7 @@ jobs:
      - name: Generate testnets
        working-directory: test/e2e
        # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 4 -d networks/nightly
+        run: ./build/generator -g 2 -d networks/nightly

      - name: Run testnets in group ${{ matrix.group }}
        working-directory: test/e2e
@@ -49,7 +47,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Notify Slack on failure
-        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
+        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
        env:
          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
          SLACK_CHANNEL: tendermint-internal
@@ -58,19 +56,3 @@ 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@f565a63638bd3615e76249bffab00fcb9dab90f7
-        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: ''
@@ -1,73 +1,73 @@
-# Runs randomly generated E2E testnets nightly on master
+# Runs randomly generated E2E testnets nightly on main

-# !! If you change something in this file, you probably want
-# to update the e2e-nightly-34x workflow as well!
+# !! 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.

-name: e2e-nightly-master
+name: e2e-nightly-main
 on:
-  workflow_dispatch: # allow running workflow manually
  schedule:
    - cron: '0 2 * * *'

 jobs:
-  e2e-nightly-test-2:
+  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']
+        group: ['00', '01', '02', '03', "04"]
    runs-on: ubuntu-latest
    timeout-minutes: 60
    steps:
      - uses: actions/setup-go@v3
        with:
-          go-version: '1.15'
+          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
+        run: make -j2 docker generator runner tests

      - name: Generate testnets
        working-directory: test/e2e
        # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 4 -d networks/nightly
+        run: ./build/generator -g 5 -d networks/nightly/

-      - name: Run testnets in group ${{ matrix.group }}
+      - name: Run ${{ matrix.p2p }} p2p testnets
        working-directory: test/e2e
        run: ./run-multiple.sh networks/nightly/*-group${{ matrix.group }}-*.toml

-  e2e-nightly-fail-2:
-    needs: e2e-nightly-test-2
+  e2e-nightly-fail:
+    needs: e2e-nightly-test
    if: ${{ failure() }}
    runs-on: ubuntu-latest
    steps:
      - name: Notify Slack on failure
-        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
+        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
        env:
          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
          SLACK_CHANNEL: tendermint-internal
          SLACK_USERNAME: Nightly E2E Tests
          SLACK_ICON_EMOJI: ':skull:'
          SLACK_COLOR: danger
-          SLACK_MESSAGE: Nightly E2E tests failed on master
+          SLACK_MESSAGE: Nightly E2E tests failed on main
          SLACK_FOOTER: ''

-  e2e-nightly-success: # may turn this off once they seem to pass consistently
-    needs: e2e-nightly-test-2
+  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@f565a63638bd3615e76249bffab00fcb9dab90f7
+        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
        env:
          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
          SLACK_CHANNEL: tendermint-internal
          SLACK_USERNAME: Nightly E2E Tests
          SLACK_ICON_EMOJI: ':white_check_mark:'
          SLACK_COLOR: good
-          SLACK_MESSAGE: Nightly E2E tests passed on master
+          SLACK_MESSAGE: Nightly E2E tests passed on main
          SLACK_FOOTER: ''
@@ -1,11 +1,12 @@
 name: e2e
-# Runs the CI end-to-end test network on all pushes to master or release branches
+# Runs the CI end-to-end test network on all pushes to main 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:
-      - master
+      - main
      - release/**

 jobs:
@@ -15,7 +16,7 @@ jobs:
    steps:
      - uses: actions/setup-go@v3
        with:
-          go-version: '^1.15.4'
+          go-version: '1.17'
      - uses: actions/checkout@v3
      - uses: technote-space/get-diff-action@v6
        with:
@@ -27,15 +28,10 @@ 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
+        run: make -j2 docker runner tests
        if: "env.GIT_DIFF != ''"

      - name: Run CI testnet
        working-directory: test/e2e
-        run: ./build/runner -f networks/ci.toml
+        run: ./run-multiple.sh 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
@@ -1,9 +1,13 @@
 # Runs fuzzing nightly.
-name: fuzz-nightly
+name: Fuzz Tests
 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:
@@ -11,13 +15,13 @@ jobs:
    steps:
      - uses: actions/setup-go@v3
        with:
-          go-version: '1.15'
+          go-version: '1.17'

      - uses: actions/checkout@v3

      - name: Install go-fuzz
        working-directory: test/fuzz
-        run: go get -u github.com/dvyukov/go-fuzz/go-fuzz github.com/dvyukov/go-fuzz/go-fuzz-build
+        run: go install github.com/dvyukov/go-fuzz/go-fuzz@latest github.com/dvyukov/go-fuzz/go-fuzz-build@latest

      - name: Fuzz mempool
        working-directory: test/fuzz
@@ -49,14 +53,14 @@ jobs:
        with:
          name: crashers
          path: test/fuzz/**/crashers
-          retention-days: 1
+          retention-days: 3

      - name: Archive suppressions
        uses: actions/upload-artifact@v3
        with:
          name: suppressions
          path: test/fuzz/**/suppressions
-          retention-days: 1
+          retention-days: 3

      - name: Set crashers count
        working-directory: test/fuzz
@@ -72,7 +76,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Notify Slack if any crashers
-        uses: rtCamp/action-slack-notify@f565a63638bd3615e76249bffab00fcb9dab90f7
+        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
        env:
          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
          SLACK_CHANNEL: tendermint-internal
@@ -0,0 +1,16 @@
+name: Janitor
+# Janitor cleans up previous runs of various workflows
+# To add more workflows to cancel visit https://api.github.com/repos/tendermint/tendermint/actions/workflows and find the actions name
+on:
+  pull_request:
+
+jobs:
+  cancel:
+    name: "Cancel Previous Runs"
+    runs-on: ubuntu-latest
+    timeout-minutes: 3
+    steps:
+      - uses: styfle/cancel-workflow-action@0.10.0
+        with:
+          workflow_id: 1041851,1401230,2837803
+          access_token: ${{ github.token }}
@@ -1,12 +0,0 @@
-name: Check Markdown links
-on:
-  schedule:
-    - cron: '* */24 * * *'
-jobs:
-  markdown-link-check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: creachadair/github-action-markdown-link-check@master
-        with:
-          folder-path: "docs"
@@ -1,12 +1,18 @@
-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.
+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:
-      - master
+      - main
 jobs:
  golangci:
    name: golangci-lint
@@ -16,7 +22,7 @@ jobs:
      - uses: actions/checkout@v3
      - uses: actions/setup-go@v3
        with:
-          go-version: '^1.16'
+          go-version: '1.17'
      - uses: technote-space/get-diff-action@v6
        with:
          PATTERNS: |
@@ -25,7 +31,9 @@ jobs:
            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.
+          # 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 }}
@@ -1,14 +1,14 @@
-name: Lint
+name: Markdown Linter
 on:
  push:
    branches:
-      - master
+      - main
    paths:
      - "**.md"
      - "**.yml"
      - "**.yaml"
  pull_request:
-    branches: [master]
+    branches: [main]
    paths:
      - "**.md"
      - "**.yml"
@@ -21,12 +21,12 @@ jobs:
      - name: Checkout Code
        uses: actions/checkout@v3
      - name: Lint Code Base
-        uses: docker://github/super-linter:v3
+        uses: docker://github/super-linter:v4
        env:
-          LINTER_RULES_PATH: .
          VALIDATE_ALL_CODEBASE: true
-          DEFAULT_BRANCH: master
+          DEFAULT_BRANCH: main
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          VALIDATE_MD: true
          VALIDATE_OPENAPI: true
          VALIDATE_YAML: true
+          YAML_CONFIG_FILE: yaml-lint.yml
@@ -0,0 +1,23 @@
+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
@@ -5,7 +5,7 @@ on:
      - 'proto/**'
  push:
    branches:
-      - v0.34.x
+      - main
    paths:
      - 'proto/**'

@@ -1,22 +0,0 @@
-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@v3
-      - name: lint
-        run: make proto-lint
-  proto-breakage:
-    runs-on: ubuntu-latest
-    timeout-minutes: 4
-    steps:
-      - uses: actions/checkout@v3
-      - name: check-breakage
-        run: make proto-check-breaking-ci
@@ -3,7 +3,7 @@ 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:
@@ -16,12 +16,20 @@ jobs:

      - uses: actions/setup-go@v3
        with:
-          go-version: '^1.15.4'
+          go-version: '1.17'

-      - run: echo https://github.com/tendermint/tendermint/blob/${GITHUB_REF#refs/tags/}/CHANGELOG.md#${GITHUB_REF#refs/tags/} > ../release_notes.md 
-
-      - name: Run GoReleaser
+      - 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
+
+      - name: Release
+        uses: goreleaser/goreleaser-action@v3
+        if: startsWith(github.ref, 'refs/tags/')
        with:
          version: latest
          args: release --rm-dist --release-notes=../release_notes.md
@@ -13,6 +13,8 @@ jobs:
          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: 10
-          days-before-close: 4
+          days-before-stale: -1
+          days-before-close: -1
+          days-before-pr-stale: 10
+          days-before-pr-close: 4
          exempt-pr-labels: "S:wip"
@@ -1,146 +1,34 @@
-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
+name: Test
 on:
  pull_request:
  push:
+    paths:
+      - "**.go"
    branches:
-      - master
+      - main
      - release/**

 jobs:
-  cleanup-runs:
+  tests:
    runs-on: ubuntu-latest
-    steps:
-      - uses: rokroskar/workflow-run-cleanup-action@master
-        env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-    if: "!startsWith(github.ref, 'refs/tags/') && github.ref != 'refs/heads/master'"
-
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
+    strategy:
+      fail-fast: false
+      matrix:
+        part: ["00", "01", "02", "03", "04", "05"]
    steps:
      - uses: actions/setup-go@v3
        with:
-          go-version: "^1.15.4"
+          go-version: "1.17"
      - uses: actions/checkout@v3
      - uses: technote-space/get-diff-action@v6
        with:
          PATTERNS: |
            **/**.go
+            "!test/"
            go.mod
            go.sum
-      - name: install
-        run: make install install_abci
-        if: "env.GIT_DIFF != ''"
-      - uses: actions/cache@v3
-        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@v3
-        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@v3
-        with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - uses: actions/cache@v3
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-        if: env.GIT_DIFF
-      - uses: actions/cache@v3
-        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@v3
-        with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - uses: actions/cache@v3
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-        if: env.GIT_DIFF
-      - uses: actions/cache@v3
-        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@v3
-        with:
-          go-version: "^1.15.4"
-      - uses: actions/checkout@v3
-      - uses: technote-space/get-diff-action@v6
-        with:
-          PATTERNS: |
-            **/**.go
-            go.mod
-            go.sum
-      - uses: actions/cache@v3
-        with:
-          path: ~/go/pkg/mod
-          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
-          restore-keys: |
-            ${{ runner.os }}-go-
-        if: env.GIT_DIFF
-      - uses: actions/cache@v3
-        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
+            Makefile
+      - name: Run Go Tests
+        run: |
+          make test-group-${{ matrix.part }} NUM_SPLIT=6
        if: env.GIT_DIFF
@@ -1,58 +1,56 @@
-*.swp
-*.swo
-.bak
 *.bak
+*.iml
+*.swo
+*.swp
+*/.glide
+*/vendor
 .DS_Store
-build/*
-rpc/test/.tendermint
-.tendermint
-remote_dump
+.bak
+.idea/
 .revision
-vendor
+.tendermint
+.tendermint-lite
+.terraform
 .vagrant
-test/e2e/build
-test/maverick/maverick
-test/e2e/networks/*/
-test/p2p/data/
-test/logs
+.vendor-new/
+.vscode/
+abci/abci-cli
+addrbook.json
+artifacts/*
+build/*
 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
-
-scripts/wal2json/wal2json
-scripts/cutWALUntil/cutWALUntil
-
-.idea/
-*.iml
-
-.vscode/
-
 libs/pubsub/query/fuzz_test/output
+profile\.out
+remote_dump
+rpc/test/.tendermint
+scripts/cutWALUntil/cutWALUntil
+scripts/wal2json/wal2json
 shunit2
-
-.tendermint-lite
-addrbook.json
-
-*/vendor
-.vendor-new/
-*/.glide
-.terraform
 terraform.tfstate
 terraform.tfstate.backup
 terraform.tfstate.d
-profile\.out
+test/app/grpc_client
 test/e2e/build
 test/e2e/networks/*/
 test/logs
-test/maverick/maverick
 test/p2p/data/
 vendor
 test/fuzz/**/corpus
 test/fuzz/**/crashers
 test/fuzz/**/suppressions
 test/fuzz/**/*.zip
+proto/spec/**/*.pb.go
+*.aux
+*.bbl
+*.blg
+*.log
+*.pdf
+*.gz
+*.dvi
@@ -8,14 +8,7 @@ linters:
    - dupl
    - errcheck
    - exportloopref
-    # - funlen
-    # - gochecknoglobals
-    # - gochecknoinits
-    # - gocognit
    - goconst
-    # - gocritic
-    # - gocyclo
-    # - godox
    - gofmt
    - goimports
    - revive
@@ -23,48 +16,31 @@ linters:
    - gosimple
    - govet
    - ineffassign
-    # - interfacer
-    - lll
-    # - maligned
-    # - misspell
+    - misspell
    - nakedret
    - nolintlint
    - prealloc
    - staticcheck
    - structcheck
    - stylecheck
-    # - typecheck
+    - typecheck
    - unconvert
-    # - unparam
    - unused
    - varcheck
-    # - whitespace
-    # - wsl

 issues:
  exclude-rules:
    - path: _test\.go
      linters:
        - gosec
-    - linters:
-        - lll
-      source: "https://"
  max-same-issues: 50

 linters-settings:
  dogsled:
    max-blank-identifiers: 3
-  maligned:
-    suggest-new: true
-  # govet:
-  #   check-shadowing: true
-  revive:
+  golint:
    min-confidence: 0
  maligned:
    suggest-new: true
  misspell:
    locale: US
-    ignore-words:
-      - behaviour
-
-
@@ -5,7 +5,7 @@ env:
  - GO111MODULE=on

 builds:
-  - id: "Tendermint"
+  - id: "tendermint"
    main: ./cmd/tendermint/main.go
    ldflags:
      - -s -w -X github.com/tendermint/tendermint/version.TMCoreSemVer={{ .Version }}
@@ -26,3 +26,11 @@ checksum:

 release:
  name_template: "{{.Version}} (WARNING: BETA SOFTWARE)"
+
+archives:
+  - files:
+      - LICENSE
+      - README.md
+      - UPGRADING.md
+      - SECURITY.md
+      - CHANGELOG.md
@@ -1,5 +1,12 @@
-default: true,
-MD007: { "indent": 4 }
+# 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}
 MD013: false
 MD024: { siblings_only: true }
 MD025: false
@@ -0,0 +1,6 @@
+{
+    "retryOn429": true,
+    "retryCount": 5,
+    "fallbackRetryDelay": "30s",
+    "aliveStatusCodes": [200, 206, 503]
+}
@@ -1,10 +0,0 @@
-pull_request_rules:
-  - name: Automerge to master
-    conditions:
-      - base=master
-      - label=S:automerge
-    actions:
-      merge:
-        method: squash
-        strict: true
-        commit_message: title+body
@@ -1,8 +0,0 @@
-{
-  "protoc": {
-    "options": [
-      "--proto_path=${workspaceRoot}/proto",
-      "--proto_path=${workspaceRoot}/third_party/proto"
-    ]
-  }
-}
@@ -1,5 +1,6 @@
 PACKAGES=$(shell go list ./...)
-OUTPUT?=build/tendermint
+BUILDDIR?=$(CURDIR)/build
+OUTPUT?=$(BUILDDIR)/tendermint

 BUILD_TAGS?=tendermint

@@ -286,3 +287,25 @@ 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
@@ -171,12 +171,6 @@ func (app *Application) Query(reqQuery types.RequestQuery) (resQuery types.Respo
 	return resQuery
 }

-func (app *Application) PrepareProposal(
-	req types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	return types.ResponsePrepareProposal{
-		BlockData: req.BlockData}
-}
-
 func (app *Application) ProcessProposal(
 	req types.RequestProcessProposal) types.ResponseProcessProposal {
 	for _, tx := range req.Txs {
@@ -76,6 +76,10 @@ 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)
 }
@@ -172,11 +176,7 @@ func (app *PersistentKVStoreApplication) ApplySnapshotChunk(

 func (app *PersistentKVStoreApplication) PrepareProposal(
 	req types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	if len(req.BlockData) > 1 && false { // this breaks TC: TestReactorValidatorSetChanges
-		req.BlockData[1] = []byte("modified tx")
-	}
-
-	return types.ResponsePrepareProposal{BlockData: req.BlockData}
+	return types.ResponsePrepareProposal{TxRecords: app.substPrepareTx(req.Txs, req.MaxTxBytes)}
 }

 func (app *PersistentKVStoreApplication) ProcessProposal(
@@ -303,3 +303,50 @@ 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...)
+}
@@ -22,11 +22,12 @@ type Application interface {
 	// Consensus Connection
 	InitChain(RequestInitChain) ResponseInitChain // Initialize blockchain w validators/other info from TendermintCore
 	PrepareProposal(RequestPrepareProposal) ResponsePrepareProposal
+	ProcessProposal(RequestProcessProposal) ResponseProcessProposal
 	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
 	Commit() ResponseCommit                          // Commit the state and return the application Merkle root hash
-	ProcessProposal(RequestProcessProposal) ResponseProcessProposal
+	

 	// State Sync Connection
 	ListSnapshots(RequestListSnapshots) ResponseListSnapshots                // List available snapshots
@@ -100,9 +101,19 @@ func (BaseApplication) ApplySnapshotChunk(req RequestApplySnapshotChunk) Respons
 }

 func (BaseApplication) PrepareProposal(req RequestPrepareProposal) ResponsePrepareProposal {
-	return ResponsePrepareProposal{
-		BlockData: req.BlockData,
+	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 {
@@ -0,0 +1,224 @@
+// Code generated by mockery v2.14.0. 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
+}
+
+// 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
+}
@@ -0,0 +1,176 @@
+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
+}
+
+// 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
+}
@@ -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
@@ -1,10 +1,10 @@
 /*
-Package Behaviour provides a mechanism for reactors to report behaviour of peers.
+Package Behavior provides a mechanism for reactors to report behavior of peers.

-Instead of a reactor calling the switch directly it will call the behaviour module which will
+Instead of a reactor calling the switch directly it will call the behavior module which will
 handle the stoping and marking peer as good on behalf of the reactor.

-There are four different behaviours a reactor can report.
+There are four different behaviors a reactor can report.

 1. bad message

@@ -39,4 +39,4 @@ type blockPart struct {
 This message will request the peer be marked as good

 */
-package behaviour
+package behaviour //nolint:misspell
@@ -1,12 +1,12 @@
-package behaviour
+package behaviour //nolint:misspell

 import (
 	"github.com/tendermint/tendermint/p2p"
 )

-// PeerBehaviour is a struct describing a behaviour a peer performed.
+// PeerBehaviour is a struct describing a behavior a peer performed.
 // `peerID` identifies the peer and reason characterizes the specific
-// behaviour performed by the peer.
+// behavior performed by the peer.
 type PeerBehaviour struct {
 	peerID p2p.ID
 	reason interface{}
@@ -1,4 +1,4 @@
-package behaviour
+package behaviour //nolint:misspell

 import (
 	"errors"
@@ -7,13 +7,13 @@ import (
 	"github.com/tendermint/tendermint/p2p"
 )

-// Reporter provides an interface for reactors to report the behaviour
+// Reporter provides an interface for reactors to report the behavior
 // of peers synchronously to other components.
 type Reporter interface {
-	Report(behaviour PeerBehaviour) error
+	Report(behavior PeerBehaviour) error
 }

-// SwitchReporter reports peer behaviour to an internal Switch.
+// SwitchReporter reports peer behavior to an internal Switch.
 type SwitchReporter struct {
 	sw *p2p.Switch
 }
@@ -25,14 +25,14 @@ func NewSwitchReporter(sw *p2p.Switch) *SwitchReporter {
 	}
 }

-// Report reports the behaviour of a peer to the Switch.
-func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {
-	peer := spbr.sw.Peers().Get(behaviour.peerID)
+// Report reports the behavior of a peer to the Switch.
+func (spbr *SwitchReporter) Report(behavior PeerBehaviour) error {
+	peer := spbr.sw.Peers().Get(behavior.peerID)
 	if peer == nil {
 		return errors.New("peer not found")
 	}

-	switch reason := behaviour.reason.(type) {
+	switch reason := behavior.reason.(type) {
 	case consensusVote, blockPart:
 		spbr.sw.MarkPeerAsGood(peer)
 	case badMessage:
@@ -48,14 +48,14 @@ func (spbr *SwitchReporter) Report(behaviour PeerBehaviour) error {

 // MockReporter is a concrete implementation of the Reporter
 // interface used in reactor tests to ensure reactors report the correct
-// behaviour in manufactured scenarios.
+// behavior in manufactured scenarios.
 type MockReporter struct {
 	mtx tmsync.RWMutex
 	pb  map[p2p.ID][]PeerBehaviour
 }

 // NewMockReporter returns a Reporter which records all reported
-// behaviours in memory.
+// behaviors 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(behaviour PeerBehaviour) error {
+func (mpbr *MockReporter) Report(behavior PeerBehaviour) error {
 	mpbr.mtx.Lock()
 	defer mpbr.mtx.Unlock()
-	mpbr.pb[behaviour.peerID] = append(mpbr.pb[behaviour.peerID], behaviour)
+	mpbr.pb[behavior.peerID] = append(mpbr.pb[behavior.peerID], behavior)

 	return nil
 }

-// GetBehaviours returns all behaviours reported on the peer identified by peerID.
+// GetBehaviours returns all behaviors reported on the peer identified by peerID.
 func (mpbr *MockReporter) GetBehaviours(peerID p2p.ID) []PeerBehaviour {
 	mpbr.mtx.RLock()
 	defer mpbr.mtx.RUnlock()
@@ -1,41 +1,41 @@
-package behaviour_test
+package behaviour_test //nolint:misspell

 import (
 	"sync"
 	"testing"

-	bh "github.com/tendermint/tendermint/behaviour"
+	bh "github.com/tendermint/tendermint/behaviour" //nolint:misspell
 	"github.com/tendermint/tendermint/p2p"
 )

 // TestMockReporter tests the MockReporter's ability to store reported
-// peer behaviour in memory indexed by the peerID.
+// peer behavior in memory indexed by the peerID.
 func TestMockReporter(t *testing.T) {
 	var peerID p2p.ID = "MockPeer"
 	pr := bh.NewMockReporter()

-	behaviours := pr.GetBehaviours(peerID)
-	if len(behaviours) != 0 {
-		t.Error("Expected to have no behaviours reported")
+	behaviors := pr.GetBehaviours(peerID)
+	if len(behaviors) != 0 {
+		t.Error("Expected to have no behaviors reported")
 	}

 	badMessage := bh.BadMessage(peerID, "bad message")
 	if err := pr.Report(badMessage); err != nil {
 		t.Error(err)
 	}
-	behaviours = pr.GetBehaviours(peerID)
-	if len(behaviours) != 1 {
-		t.Error("Expected the peer have one reported behaviour")
+	behaviors = pr.GetBehaviours(peerID)
+	if len(behaviors) != 1 {
+		t.Error("Expected the peer have one reported behavior")
 	}

-	if behaviours[0] != badMessage {
+	if behaviors[0] != badMessage {
 		t.Error("Expected Bad Message to have been reported")
 	}
 }

 type scriptItem struct {
-	peerID    p2p.ID
-	behaviour bh.PeerBehaviour
+	peerID   p2p.ID
+	behavior 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 _, behaviour := range a {
-		aHistogram[behaviour]++
+	for _, behavior := range a {
+		aHistogram[behavior]++
 	}

-	for _, behaviour := range b {
-		bHistogram[behaviour]++
+	for _, behavior := range b {
+		bHistogram[behavior]++
 	}

 	if len(aHistogram) != len(bHistogram) {
 		return false
 	}

-	for _, behaviour := range a {
-		if aHistogram[behaviour] != bHistogram[behaviour] {
+	for _, behavior := range a {
+		if aHistogram[behavior] != bHistogram[behavior] {
 			return false
 		}
 	}

-	for _, behaviour := range b {
-		if bHistogram[behaviour] != aHistogram[behaviour] {
+	for _, behavior := range b {
+		if bHistogram[behavior] != aHistogram[behavior] {
 			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 behaviours can be compared for the behaviours they contain and the
-// freequencies that those behaviours occur.
+// of peer behaviors can be compared for the behaviors they contain and the
+// freequencies that those behaviors 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 behaviours
+			// Single behaviors
 			{[]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 behaviours
+			// Different behaviors
 			{[]bh.PeerBehaviour{consensusVote}, []bh.PeerBehaviour{blockPart}},
-			// Same behaviour with different frequencies
+			// Same behavior 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
-			behaviours []bh.PeerBehaviour
+			peerID    p2p.ID
+			behaviors []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.behaviour); err != nil {
+					if err := pr.Report(pb.behavior); 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.behaviours {
+			for _, reason := range item.behaviors {
 				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.behaviours) {
+		if !equalBehaviours(reported, items.behaviors) {
 			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
-				items.peerID, items.behaviours, reported)
+				items.peerID, items.behaviors, reported)
 		}
 	}
 }
@@ -360,14 +360,20 @@ FOR_LOOP:
 				didProcessCh <- struct{}{}
 			}

-			firstParts := first.MakePartSet(types.BlockPartSizeBytes)
+			firstParts, err := first.MakePartSet(types.BlockPartSizeBytes)
+			if err != nil {
+				bcR.Logger.Error("failed to make ",
+					"height", first.Height,
+					"err", err.Error())
+				break FOR_LOOP
+			}
 			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 {
@@ -8,6 +8,7 @@ import (
 	"time"

 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"

 	dbm "github.com/tendermint/tm-db"
@@ -15,7 +16,7 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/mempool/mock"
+	mpmocks "github.com/tendermint/tendermint/mempool/mocks"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
@@ -53,6 +54,7 @@ type BlockchainReactorPair struct {
 }

 func newBlockchainReactor(
+	t *testing.T,
 	logger log.Logger,
 	genDoc *types.GenesisDoc,
 	privVals []types.PrivValidator,
@@ -79,6 +81,18 @@ 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.
@@ -86,7 +100,7 @@ func newBlockchainReactor(
 	db := dbm.NewMemDB()
 	stateStore = sm.NewStore(db)
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
-		mock.Mempool{}, sm.EmptyEvidencePool{})
+		mp, sm.EmptyEvidencePool{})
 	if err = stateStore.Save(state); err != nil {
 		panic(err)
 	}
@@ -115,7 +129,8 @@ func newBlockchainReactor(

 		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)

-		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
+		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
+		require.NoError(t, err)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}

 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
@@ -141,8 +156,8 @@ func TestNoBlockResponse(t *testing.T) {

 	reactorPairs := make([]BlockchainReactorPair, 2)

-	reactorPairs[0] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, maxBlockHeight)
-	reactorPairs[1] = newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
+	reactorPairs[0] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, maxBlockHeight)
+	reactorPairs[1] = newBlockchainReactor(t, log.TestingLogger(), genDoc, privVals, 0)

 	p2p.MakeConnectedSwitches(config.P2P, 2, func(i int, s *p2p.Switch) *p2p.Switch {
 		s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
@@ -203,7 +218,7 @@ func TestBadBlockStopsPeer(t *testing.T) {

 	// Other chain needs a different validator set
 	otherGenDoc, otherPrivVals := randGenesisDoc(1, false, 30)
-	otherChain := newBlockchainReactor(log.TestingLogger(), otherGenDoc, otherPrivVals, maxBlockHeight)
+	otherChain := newBlockchainReactor(t, log.TestingLogger(), otherGenDoc, otherPrivVals, maxBlockHeight)

 	defer func() {
 		err := otherChain.reactor.Stop()
@@ -214,10 +229,10 @@ func TestBadBlockStopsPeer(t *testing.T) {

 	reactorPairs := make([]BlockchainReactorPair, 4)

-	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)
+	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)

 	switches := p2p.MakeConnectedSwitches(config.P2P, 4, func(i int, s *p2p.Switch) *p2p.Switch {
 		s.AddReactor("BLOCKCHAIN", reactorPairs[i].reactor)
@@ -255,7 +270,7 @@ func TestBadBlockStopsPeer(t *testing.T) {
 	// race, but can't be easily avoided.
 	reactorPairs[3].reactor.store = otherChain.reactor.store

-	lastReactorPair := newBlockchainReactor(log.TestingLogger(), genDoc, privVals, 0)
+	lastReactorPair := newBlockchainReactor(t, 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 {
@@ -5,7 +5,7 @@ import (
 	"reflect"
 	"time"

-	"github.com/tendermint/tendermint/behaviour"
+	"github.com/tendermint/tendermint/behaviour" //nolint:misspell
 	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 = behaviour.NewSwitchReporter(bcR.BaseReactor.Switch)
+	// bcR.swReporter = behavior.NewSwitchReporter(bcR.BaseReactor.Switch)

 	return bcR
 }
@@ -465,7 +465,13 @@ func (bcR *BlockchainReactor) processBlock() error {

 	chainID := bcR.initialState.ChainID

-	firstParts := first.MakePartSet(types.BlockPartSizeBytes)
+	firstParts, err := first.MakePartSet(types.BlockPartSizeBytes)
+	if err != nil {
+		bcR.Logger.Error("failed to make ",
+			"height", first.Height,
+			"err", err.Error())
+		return err
+	}
 	firstPartSetHeader := firstParts.Header()
 	firstID := types.BlockID{Hash: first.Hash(), PartSetHeader: firstPartSetHeader}
 	// Finally, verify the first block using the second's commit
@@ -9,6 +9,7 @@ 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 +17,12 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/mempool/mock"
+	mpmocks "github.com/tendermint/tendermint/mempool/mocks"
 	"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"
@@ -110,6 +112,18 @@ 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.
@@ -117,7 +131,7 @@ func newBlockchainReactor(
 	db := dbm.NewMemDB()
 	stateStore = sm.NewStore(db)
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
-		mock.Mempool{}, sm.EmptyEvidencePool{})
+		mp, sm.EmptyEvidencePool{})
 	if err = stateStore.Save(state); err != nil {
 		panic(err)
 	}
@@ -133,9 +147,10 @@ func newBlockchainReactor(
 			lastCommit = types.NewCommit(vote.Height, vote.Round, lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
 		}

-		thisBlock := makeBlock(blockHeight, state, lastCommit)
+		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)

-		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
+		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
+		require.NoError(t, err)
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}

 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
@@ -345,21 +360,6 @@ 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
 }
@@ -158,11 +158,12 @@ func (state *pcState) handle(event Event) (Event, error) {
 			return noOp, nil
 		}

-		var (
-			first, second = firstItem.block, secondItem.block
-			firstParts    = first.MakePartSet(types.BlockPartSizeBytes)
-			firstID       = types.BlockID{Hash: first.Hash(), PartSetHeader: firstParts.Header()}
-		)
+		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()}

 		// verify if +second+ last commit "confirms" +first+ block
 		err = state.context.verifyCommit(tmState.ChainID, firstID, first.Height, second.LastCommit)
@@ -82,7 +82,7 @@ func executeProcessorTests(t *testing.T, tests []testFields) {
 					}
 				}()

-				// First step must always initialise the currentState as state.
+				// First step must always initialize the currentState as state.
 				if step.currentState != nil {
 					state = makeState(step.currentState)
 				}
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"time"

-	"github.com/tendermint/tendermint/behaviour"
+	"github.com/tendermint/tendermint/behaviour" //nolint:misspell
 	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, signalled by r.events being non-nil. If state is non-nil,
+// startSync begins a fast sync, signaled by r.events being non-nil. If state is non-nil,
 // the scheduler and processor is updated with this state on startup.
 func (r *BlockchainReactor) startSync(state *state.State) error {
 	r.mtx.Lock()
@@ -10,16 +10,17 @@ 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"
+	"github.com/tendermint/tendermint/behaviour" //nolint:misspell
 	bc "github.com/tendermint/tendermint/blockchain"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
-	"github.com/tendermint/tendermint/mempool/mock"
+	mpmocks "github.com/tendermint/tendermint/mempool/mocks"
 	"github.com/tendermint/tendermint/p2p"
 	"github.com/tendermint/tendermint/p2p/conn"
 	bcproto "github.com/tendermint/tendermint/proto/tendermint/blockchain"
@@ -143,8 +144,8 @@ type testReactorParams struct {
 	mockA       bool
 }

-func newTestReactor(p testReactorParams) *BlockchainReactor {
-	store, state, _ := newReactorStore(p.genDoc, p.privVals, p.startHeight)
+func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
+	store, state, _ := newReactorStore(t, p.genDoc, p.privVals, p.startHeight)
 	reporter := behaviour.NewMockReporter()

 	var appl blockApplier
@@ -152,6 +153,18 @@ func newTestReactor(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)
@@ -161,7 +174,7 @@ func newTestReactor(p testReactorParams) *BlockchainReactor {
 		}
 		db := dbm.NewMemDB()
 		stateStore := sm.NewStore(db)
-		appl = sm.NewBlockExecutor(stateStore, p.logger, proxyApp.Consensus(), mock.Mempool{}, sm.EmptyEvidencePool{})
+		appl = sm.NewBlockExecutor(stateStore, p.logger, proxyApp.Consensus(), mp, sm.EmptyEvidencePool{})
 		if err = stateStore.Save(state); err != nil {
 			panic(err)
 		}
@@ -302,7 +315,7 @@ func newTestReactor(p testReactorParams) *BlockchainReactor {
 // 		t.Run(tt.name, func(t *testing.T) {
 // 			reactor := newTestReactor(params)
 // 			reactor.Start()
-// 			reactor.reporter = behaviour.NewMockReporter()
+// 			reactor.reporter = behavior.NewMockReporter()
 // 			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
 // 			reactor.io = mockSwitch
 // 			// time for go routines to start
@@ -392,7 +405,7 @@ func TestReactorHelperMode(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			reactor := newTestReactor(params)
+			reactor := newTestReactor(t, params)
 			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
 			reactor.io = mockSwitch
 			err := reactor.Start()
@@ -435,7 +448,7 @@ func TestReactorSetSwitchNil(t *testing.T) {
 	defer os.RemoveAll(config.RootDir)
 	genDoc, privVals := randGenesisDoc(config.ChainID(), 1, false, 30)

-	reactor := newTestReactor(testReactorParams{
+	reactor := newTestReactor(t, testReactorParams{
 		logger:   log.TestingLogger(),
 		genDoc:   genDoc,
 		privVals: privVals,
@@ -474,6 +487,7 @@ 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) {
@@ -496,10 +510,22 @@ 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(),
-		mock.Mempool{}, sm.EmptyEvidencePool{})
+		mp, sm.EmptyEvidencePool{})
 	if err = stateStore.Save(state); err != nil {
 		panic(err)
 	}
@@ -527,7 +553,9 @@ func newReactorStore(

 		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)

-		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
+		thisParts, err := thisBlock.MakePartSet(types.BlockPartSizeBytes)
+		require.NoError(t, err)
+
 		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}

 		state, _, err = blockExec.ApplyBlock(state, blockID, thisBlock)
@@ -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 initialise the currentState as state.
+				// First step must always initialize the currentState as state.
 				if step.currentSc != nil {
 					sc = newTestScheduler(*step.currentSc)
 				}
@@ -14,7 +14,7 @@ import (
 	tmtime "github.com/tendermint/tendermint/types/time"
 )

-// InitFilesCmd initialises a fresh Tendermint Core instance.
+// InitFilesCmd initializes a fresh Tendermint Core instance.
 var InitFilesCmd = &cobra.Command{
 	Use:   "init",
 	Short: "Initialize Tendermint",
@@ -101,7 +101,7 @@ func init() {
 }

 func runProxy(cmd *cobra.Command, args []string) error {
-	// Initialise logger.
+	// Initialize logger.
 	logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout))
 	var option log.Option
 	if verbose {
@@ -370,7 +370,7 @@ type RPCConfig struct {
 	//
 	// Enabling this parameter will cause the WebSocket connection to be closed
 	// instead if it cannot read fast enough, allowing for greater
-	// predictability in subscription behaviour.
+	// 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
@@ -230,7 +230,7 @@ experimental_websocket_write_buffer_size = {{ .RPC.WebSocketWriteBufferSize }}
 #
 # 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 behaviour.
+# 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.
@@ -211,9 +211,11 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		}
 		proposerAddr := lazyProposer.privValidatorPubKey.Address()

-		block, blockParts := lazyProposer.blockExec.CreateProposalBlock(
-			lazyProposer.Height, lazyProposer.state, commit, proposerAddr,
-		)
+		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)

 		// Flush the WAL. Otherwise, we may not recompute the same proposal to sign,
 		// and the privValidator will refuse to sign anything.
@@ -461,7 +463,10 @@ 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, blockParts1 := cs.createProposalBlock()
+	block1, err := cs.createProposalBlock()
+	require.NoError(t, err)
+	blockParts1, err := block1.MakePartSet(types.BlockPartSizeBytes)
+	require.NoError(t, err)
 	polRound, propBlockID := cs.ValidRound, types.BlockID{Hash: block1.Hash(), PartSetHeader: blockParts1.Header()}
 	proposal1 := types.NewProposal(height, round, polRound, propBlockID)
 	p1 := proposal1.ToProto()
@@ -475,7 +480,10 @@ 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, blockParts2 := cs.createProposalBlock()
+	block2, err := cs.createProposalBlock()
+	require.NoError(t, err)
+	blockParts2, err := block2.MakePartSet(types.BlockPartSizeBytes)
+	require.NoError(t, err)
 	polRound, propBlockID = cs.ValidRound, types.BlockID{Hash: block2.Hash(), PartSetHeader: blockParts2.Header()}
 	proposal2 := types.NewProposal(height, round, polRound, propBlockID)
 	p2 := proposal2.ToProto()
@@ -201,13 +201,17 @@ 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, blockParts := cs1.createProposalBlock()
+	block, err := cs1.createProposalBlock()
+	require.NoError(t, err)
+	blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
+	require.NoError(t, err)
 	validRound := cs1.ValidRound
 	chainID := cs1.state.ChainID
 	cs1.mtx.Unlock()
@@ -259,7 +259,20 @@ func (app *CounterApplication) Commit() abci.ResponseCommit {

 func (app *CounterApplication) PrepareProposal(
 	req abci.RequestPrepareProposal) abci.ResponsePrepareProposal {
-	return abci.ResponsePrepareProposal{BlockData: req.BlockData}
+
+	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(
@@ -55,7 +55,7 @@ func (cs *State) readReplayMessage(msg *TimedWALMessage, newStepSub types.Subscr
 					return fmt.Errorf("roundState mismatch. Got %v; Expected %v", m2, m)
 				}
 			case <-newStepSub.Cancelled():
-				return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was cancelled")
+				return fmt.Errorf("failed to read off newStepSub.Out(). newStepSub was canceled")
 			case <-ticker:
 				return fmt.Errorf("failed to read off newStepSub.Out()")
 			}
@@ -99,7 +99,7 @@ func startNewStateAndWaitForBlock(t *testing.T, consensusReplayConfig *cfg.Confi
 	select {
 	case <-newBlockSub.Out():
 	case <-newBlockSub.Cancelled():
-		t.Fatal("newBlockSub was cancelled")
+		t.Fatal("newBlockSub was canceled")
 	case <-time.After(120 * time.Second):
 		t.Fatal("Timed out waiting for new block (see trace above)")
 	}
@@ -363,9 +363,11 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	require.NoError(t, err)
 	newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower)
 	err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx1, nil, mempl.TxInfo{})
-	assert.Nil(t, err)
-	propBlock, _ := css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	propBlockParts := propBlock.MakePartSet(partSize)
+	assert.NoError(t, err)
+	propBlock, err := css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	require.NoError(t, err)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}

 	proposal := types.NewProposal(vss[1].Height, round, -1, blockID)
@@ -393,9 +395,11 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	require.NoError(t, err)
 	updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25)
 	err = assertMempool(css[0].txNotifier).CheckTx(updateValidatorTx1, nil, mempl.TxInfo{})
-	assert.Nil(t, err)
-	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	propBlockParts = propBlock.MakePartSet(partSize)
+	assert.NoError(t, err)
+	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	require.NoError(t, err)
+	propBlockParts, err = propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}

 	proposal = types.NewProposal(vss[2].Height, round, -1, blockID)
@@ -430,9 +434,11 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	require.NoError(t, err)
 	newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower)
 	err = assertMempool(css[0].txNotifier).CheckTx(newValidatorTx3, nil, mempl.TxInfo{})
-	assert.Nil(t, err)
-	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	propBlockParts = propBlock.MakePartSet(partSize)
+	assert.NoError(t, err)
+	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	require.NoError(t, err)
+	propBlockParts, err = propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	newVss := make([]*validatorStub, nVals+1)
 	copy(newVss, vss[:nVals+1])
@@ -505,9 +511,11 @@ func TestSimulateValidatorsChange(t *testing.T) {
 	incrementHeight(vss...)
 	removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0)
 	err = assertMempool(css[0].txNotifier).CheckTx(removeValidatorTx3, nil, mempl.TxInfo{})
-	assert.Nil(t, err)
-	propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
-	propBlockParts = propBlock.MakePartSet(partSize)
+	assert.NoError(t, err)
+	propBlock, err = css[0].createProposalBlock() // changeProposer(t, cs1, vs2)
+	require.NoError(t, err)
+	propBlockParts, err = propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	blockID = types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	newVss = make([]*validatorStub, nVals+3)
 	copy(newVss, vss[:nVals+3])
@@ -666,7 +674,7 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 		config = sim.Config
 		chain = append([]*types.Block{}, sim.Chain...) // copy chain
 		commits = sim.Commits
-		store = newMockBlockStore(config, genesisState.ConsensusParams)
+		store = newMockBlockStore(t, config, genesisState.ConsensusParams)
 	} else { // test single node
 		testConfig := ResetConfig(fmt.Sprintf("%s_%v_s", t.Name(), mode))
 		defer os.RemoveAll(testConfig.RootDir)
@@ -691,7 +699,7 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 		require.NoError(t, err)
 		pubKey, err := privVal.GetPubKey()
 		require.NoError(t, err)
-		stateDB, genesisState, store = stateAndStore(config, pubKey, kvstore.ProtocolVersion)
+		stateDB, genesisState, store = stateAndStore(t, config, pubKey, kvstore.ProtocolVersion)

 	}
 	stateStore := sm.NewStore(stateDB)
@@ -700,7 +708,7 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin

 	state := genesisState.Copy()
 	// run the chain through state.ApplyBlock to build up the tendermint state
-	state = buildTMStateFromChain(config, stateStore, state, chain, nBlocks, mode)
+	state = buildTMStateFromChain(t, config, stateStore, state, chain, nBlocks, mode)
 	latestAppHash := state.AppHash

 	// make a new client creator
@@ -716,7 +724,7 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 		stateStore := sm.NewStore(stateDB1)
 		err := stateStore.Save(genesisState)
 		require.NoError(t, err)
-		buildAppStateFromChain(proxyApp, stateStore, genesisState, chain, nBlocks, mode)
+		buildAppStateFromChain(t, proxyApp, stateStore, genesisState, chain, nBlocks, mode)
 	}

 	// Prune block store if requested
@@ -776,19 +784,19 @@ func testHandshakeReplay(t *testing.T, config *cfg.Config, nBlocks int, mode uin
 	}
 }

-func applyBlock(stateStore sm.Store, st sm.State, blk *types.Block, proxyApp proxy.AppConns) sm.State {
+func applyBlock(t *testing.T, stateStore sm.Store, st sm.State, blk *types.Block, proxyApp proxy.AppConns) sm.State {
 	testPartSize := types.BlockPartSizeBytes
 	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool)

-	blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: blk.MakePartSet(testPartSize).Header()}
+	bps, err := blk.MakePartSet(testPartSize)
+	require.NoError(t, err)
+	blkID := types.BlockID{Hash: blk.Hash(), PartSetHeader: bps.Header()}
 	newState, _, err := blockExec.ApplyBlock(st, blkID, blk)
-	if err != nil {
-		panic(err)
-	}
+	require.NoError(t, err)
 	return newState
 }

-func buildAppStateFromChain(proxyApp proxy.AppConns, stateStore sm.Store,
+func buildAppStateFromChain(t *testing.T, proxyApp proxy.AppConns, stateStore sm.Store,
 	state sm.State, chain []*types.Block, nBlocks int, mode uint) {
 	// start a new app without handshake, play nBlocks blocks
 	if err := proxyApp.Start(); err != nil {
@@ -810,18 +818,18 @@ func buildAppStateFromChain(proxyApp proxy.AppConns, stateStore sm.Store,
 	case 0:
 		for i := 0; i < nBlocks; i++ {
 			block := chain[i]
-			state = applyBlock(stateStore, state, block, proxyApp)
+			state = applyBlock(t, stateStore, state, block, proxyApp)
 		}
 	case 1, 2, 3:
 		for i := 0; i < nBlocks-1; i++ {
 			block := chain[i]
-			state = applyBlock(stateStore, state, block, proxyApp)
+			state = applyBlock(t, stateStore, state, block, proxyApp)
 		}

 		if mode == 2 || mode == 3 {
 			// update the kvstore height and apphash
 			// as if we ran commit but not
-			state = applyBlock(stateStore, state, chain[nBlocks-1], proxyApp)
+			state = applyBlock(t, stateStore, state, chain[nBlocks-1], proxyApp)
 		}
 	default:
 		panic(fmt.Sprintf("unknown mode %v", mode))
@@ -830,6 +838,7 @@ func buildAppStateFromChain(proxyApp proxy.AppConns, stateStore sm.Store,
 }

 func buildTMStateFromChain(
+	t *testing.T,
 	config *cfg.Config,
 	stateStore sm.Store,
 	state sm.State,
@@ -860,19 +869,19 @@ func buildTMStateFromChain(
 	case 0:
 		// sync right up
 		for _, block := range chain {
-			state = applyBlock(stateStore, state, block, proxyApp)
+			state = applyBlock(t, stateStore, state, block, proxyApp)
 		}

 	case 1, 2, 3:
 		// sync up to the penultimate as if we stored the block.
 		// whether we commit or not depends on the appHash
 		for _, block := range chain[:len(chain)-1] {
-			state = applyBlock(stateStore, state, block, proxyApp)
+			state = applyBlock(t, stateStore, state, block, proxyApp)
 		}

 		// apply the final block to a state copy so we can
 		// get the right next appHash but keep the state back
-		applyBlock(stateStore, state, chain[len(chain)-1], proxyApp)
+		applyBlock(t, stateStore, state, chain[len(chain)-1], proxyApp)
 	default:
 		panic(fmt.Sprintf("unknown mode %v", mode))
 	}
@@ -891,12 +900,14 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	const appVersion = 0x0
 	pubKey, err := privVal.GetPubKey()
 	require.NoError(t, err)
-	stateDB, state, store := stateAndStore(config, pubKey, appVersion)
+	stateDB, state, store := stateAndStore(t, config, pubKey, appVersion)
 	stateStore := sm.NewStore(stateDB)
 	genDoc, _ := sm.MakeGenesisDocFromFile(config.GenesisFile())
 	state.LastValidators = state.Validators.Copy()
 	// mode = 0 for committing all the blocks
-	blocks := sf.MakeBlocks(3, &state, privVal)
+	blocks, err := sf.MakeBlocks(3, &state, privVal)
+	require.NoError(t, err)
+
 	store.chain = blocks

 	// 2. Tendermint must panic if app returns wrong hash for the first block
@@ -1099,17 +1110,19 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} {

 // fresh state and mock store
 func stateAndStore(
+	t *testing.T,
 	config *cfg.Config,
 	pubKey crypto.PubKey,
-	appVersion uint64) (dbm.DB, sm.State, *mockBlockStore) {
+	appVersion uint64,
+) (dbm.DB, sm.State, *mockBlockStore) {
 	stateDB := dbm.NewMemDB()
 	stateStore := sm.NewStore(stateDB)
-	state, _ := sm.MakeGenesisStateFromFile(config.GenesisFile())
+	state, err := sm.MakeGenesisStateFromFile(config.GenesisFile())
+	require.NoError(t, err)
 	state.Version.Consensus.App = appVersion
-	store := newMockBlockStore(config, state.ConsensusParams)
-	if err := stateStore.Save(state); err != nil {
-		panic(err)
-	}
+	store := newMockBlockStore(t, config, state.ConsensusParams)
+	require.NoError(t, stateStore.Save(state))
+
 	return stateDB, state, store
 }

@@ -1122,11 +1135,16 @@ type mockBlockStore struct {
 	chain   []*types.Block
 	commits []*types.Commit
 	base    int64
+	t       *testing.T
 }

 // TODO: NewBlockStore(db.NewMemDB) ...
-func newMockBlockStore(config *cfg.Config, params tmproto.ConsensusParams) *mockBlockStore {
-	return &mockBlockStore{config, params, nil, nil, 0}
+func newMockBlockStore(t *testing.T, config *cfg.Config, params tmproto.ConsensusParams) *mockBlockStore {
+	return &mockBlockStore{
+		config: config,
+		params: params,
+		t:      t,
+	}
 }

 func (bs *mockBlockStore) Height() int64                       { return int64(len(bs.chain)) }
@@ -1139,8 +1157,10 @@ func (bs *mockBlockStore) LoadBlockByHash(hash []byte) *types.Block {
 }
 func (bs *mockBlockStore) LoadBlockMeta(height int64) *types.BlockMeta {
 	block := bs.chain[height-1]
+	bps, err := block.MakePartSet(types.BlockPartSizeBytes)
+	require.NoError(bs.t, err)
 	return &types.BlockMeta{
-		BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(types.BlockPartSizeBytes).Header()},
+		BlockID: types.BlockID{Hash: block.Hash(), PartSetHeader: bps.Header()},
 		Header:  block.Header,
 	}
 }
@@ -1179,7 +1199,7 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	privVal := privval.LoadFilePV(config.PrivValidatorKeyFile(), config.PrivValidatorStateFile())
 	pubKey, err := privVal.GetPubKey()
 	require.NoError(t, err)
-	stateDB, state, store := stateAndStore(config, pubKey, 0x0)
+	stateDB, state, store := stateAndStore(t, config, pubKey, 0x0)
 	stateStore := sm.NewStore(stateDB)

 	oldValAddr := state.Validators.Validators[0].Address
@@ -821,7 +821,7 @@ func (cs *State) handleMsg(mi msgInfo) {

 		// We unlock here to yield to any routines that need to read the the RoundState.
 		// Previously, this code held the lock from the point at which the final block
-		// part was recieved until the block executed against the application.
+		// part was received until the block executed against the application.
 		// This prevented the reactor from being able to retrieve the most updated
 		// version of the RoundState. The reactor needs the updated RoundState to
 		// gossip the now completed block.
@@ -1131,8 +1131,17 @@ func (cs *State) defaultDecideProposal(height int64, round int32) {
 		block, blockParts = cs.ValidBlock, cs.ValidBlockParts
 	} else {
 		// Create a new proposal block from state/txs from the mempool.
-		block, blockParts = cs.createProposalBlock()
-		if block == nil {
+		var err error
+		block, err = cs.createProposalBlock()
+		if err != nil {
+			cs.Logger.Error("unable to create proposal block", "error", err)
+			return
+		} else if block == nil {
+			panic("Method createProposalBlock should not provide a nil block without errors")
+		}
+		blockParts, err = block.MakePartSet(types.BlockPartSizeBytes)
+		if err != nil {
+			cs.Logger.Error("unable to create proposal block part set", "error", err)
 			return
 		}
 	}
@@ -1187,9 +1196,9 @@ func (cs *State) isProposalComplete() bool {
 //
 // NOTE: keep it side-effect free for clarity.
 // CONTRACT: cs.privValidator is not nil.
-func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.PartSet) {
+func (cs *State) createProposalBlock() (*types.Block, error) {
 	if cs.privValidator == nil {
-		panic("entered createProposalBlock with privValidator being nil")
+		return nil, errors.New("entered createProposalBlock with privValidator being nil")
 	}

 	var commit *types.Commit
@@ -1204,20 +1213,22 @@ func (cs *State) createProposalBlock() (block *types.Block, blockParts *types.Pa
 		commit = cs.LastCommit.MakeCommit()

 	default: // This shouldn't happen.
-		cs.Logger.Error("propose step; cannot propose anything without commit for the previous block")
-		return
+		return nil, errors.New("propose step; cannot propose anything without commit for the previous block")
 	}

 	if cs.privValidatorPubKey == nil {
 		// If this node is a validator & proposer in the current round, it will
 		// miss the opportunity to create a block.
-		cs.Logger.Error("propose step; empty priv validator public key", "err", errPubKeyIsNotSet)
-		return
+		return nil, fmt.Errorf("propose step; empty priv validator public key, error: %w", errPubKeyIsNotSet)
 	}

 	proposerAddr := cs.privValidatorPubKey.Address()

-	return cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr)
+	ret, err := cs.blockExec.CreateProposalBlock(cs.Height, cs.state, commit, proposerAddr, cs.LastCommit.GetVotes())
+	if err != nil {
+		panic(err)
+	}
+	return ret, nil
 }

 // Enter: `timeoutPropose` after entering Propose.
@@ -2059,7 +2070,7 @@ func (cs *State) addVote(vote *types.Vote, peerID p2p.ID) (added bool, err error
 	}

 	// Height mismatch is ignored.
-	// Not necessarily a bad peer, but not favourable behaviour.
+	// Not necessarily a bad peer, but not favorable behavior.
 	if vote.Height != cs.Height {
 		cs.Logger.Debug("vote ignored and not added", "vote_height", vote.Height, "cs_height", cs.Height, "peer", peerID)
 		return
@@ -191,7 +191,8 @@ func TestStateBadProposal(t *testing.T) {
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)

-	propBlock, _ := cs1.createProposalBlock() // changeProposer(t, cs1, vs2)
+	propBlock, err := cs1.createProposalBlock() // changeProposer(t, cs1, vs2)
+	require.NoError(t, err)

 	// make the second validator the proposer by incrementing round
 	round++
@@ -204,7 +205,8 @@ func TestStateBadProposal(t *testing.T) {
 	}
 	stateHash[0] = (stateHash[0] + 1) % 255
 	propBlock.AppHash = stateHash
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	proposal := types.NewProposal(vs2.Height, round, -1, blockID)
 	p := proposal.ToProto()
@@ -230,13 +232,19 @@ func TestStateBadProposal(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], nil)

 	// add bad prevote from vs2 and wait for it
-	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
+	bps, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+
+	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2)
 	ensurePrevote(voteCh, height, round)

 	// wait for precommit
 	ensurePrecommit(voteCh, height, round)
 	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
-	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
+
+	bps2, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), bps2.Header(), vs2)
 }

 func TestStateOversizedBlock(t *testing.T) {
@@ -250,7 +258,8 @@ func TestStateOversizedBlock(t *testing.T) {
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)

-	propBlock, _ := cs1.createProposalBlock()
+	propBlock, err := cs1.createProposalBlock()
+	require.NoError(t, err)
 	propBlock.Data.Txs = []types.Tx{tmrand.Bytes(2001)}
 	propBlock.Header.DataHash = propBlock.Data.Hash()

@@ -258,7 +267,8 @@ func TestStateOversizedBlock(t *testing.T) {
 	round++
 	incrementRound(vss[1:]...)

-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	blockID := types.BlockID{Hash: propBlock.Hash(), PartSetHeader: propBlockParts.Header()}
 	proposal := types.NewProposal(height, round, -1, blockID)
 	p := proposal.ToProto()
@@ -290,11 +300,18 @@ func TestStateOversizedBlock(t *testing.T) {
 	// precommit on it
 	ensurePrevote(voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], nil)
-	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
+
+	bps, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+
+	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2)
 	ensurePrevote(voteCh, height, round)
 	ensurePrecommit(voteCh, height, round)
 	validatePrecommit(t, cs1, round, -1, vss[0], nil, nil)
-	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
+
+	bps2, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+	signAddVotes(cs1, tmproto.PrecommitType, propBlock.Hash(), bps2.Header(), vs2)
 }

 //----------------------------------------------------------------------------------------------------
@@ -466,9 +483,7 @@ func TestStateLockNoPOL(t *testing.T) {

 	rs := cs1.GetRoundState()

-	if rs.ProposalBlock != nil {
-		panic("Expected proposal block to be nil")
-	}
+	require.Nil(t, rs.ProposalBlock, "Expected proposal block to be nil")

 	// wait to finish prevote
 	ensurePrevote(voteCh, height, round)
@@ -476,7 +491,10 @@ func TestStateLockNoPOL(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], rs.LockedBlock.Hash())

 	// add a conflicting prevote from the other validator
-	signAddVotes(cs1, tmproto.PrevoteType, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2)
+	bps, err := rs.LockedBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+
+	signAddVotes(cs1, tmproto.PrevoteType, hash, bps.Header(), vs2)
 	ensurePrevote(voteCh, height, round)

 	// now we're going to enter prevote again, but with invalid args
@@ -489,7 +507,9 @@ func TestStateLockNoPOL(t *testing.T) {
 	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash)

 	// add conflicting precommit from vs2
-	signAddVotes(cs1, tmproto.PrecommitType, hash, rs.LockedBlock.MakePartSet(partSize).Header(), vs2)
+	bps2, err := rs.LockedBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+	signAddVotes(cs1, tmproto.PrecommitType, hash, bps2.Header(), vs2)
 	ensurePrecommit(voteCh, height, round)

 	// (note we're entering precommit for a second time this round, but with invalid args
@@ -519,7 +539,9 @@ func TestStateLockNoPOL(t *testing.T) {
 	ensurePrevote(voteCh, height, round) // prevote
 	validatePrevote(t, cs1, round, vss[0], rs.LockedBlock.Hash())

-	signAddVotes(cs1, tmproto.PrevoteType, hash, rs.ProposalBlock.MakePartSet(partSize).Header(), vs2)
+	bps0, err := rs.ProposalBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+	signAddVotes(cs1, tmproto.PrevoteType, hash, bps0.Header(), vs2)
 	ensurePrevote(voteCh, height, round)

 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
@@ -527,11 +549,13 @@ func TestStateLockNoPOL(t *testing.T) {

 	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash) // precommit nil but be locked on proposal

+	bps1, err := rs.ProposalBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	signAddVotes(
 		cs1,
 		tmproto.PrecommitType,
 		hash,
-		rs.ProposalBlock.MakePartSet(partSize).Header(),
+		bps1.Header(),
 		vs2) // NOTE: conflicting precommits at same height
 	ensurePrecommit(voteCh, height, round)

@@ -539,7 +563,7 @@ func TestStateLockNoPOL(t *testing.T) {

 	cs2, _ := randState(2) // needed so generated block is different than locked block
 	// before we time out into new round, set next proposal block
-	prop, propBlock := decideProposal(cs2, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
@@ -555,7 +579,9 @@ func TestStateLockNoPOL(t *testing.T) {

 	// now we're on a new round and not the proposer
 	// so set the proposal block
-	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlock.MakePartSet(partSize), ""); err != nil {
+	bps3, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+	if err := cs1.SetProposalAndBlock(prop, propBlock, bps3, ""); err != nil {
 		t.Fatal(err)
 	}

@@ -565,18 +591,23 @@ func TestStateLockNoPOL(t *testing.T) {
 	validatePrevote(t, cs1, 3, vss[0], cs1.LockedBlock.Hash())

 	// prevote for proposed block
-	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2)
+	bps4, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+
+	signAddVotes(cs1, tmproto.PrevoteType, propBlock.Hash(), bps4.Header(), vs2)
 	ensurePrevote(voteCh, height, round)

 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Prevote(round).Nanoseconds())
 	ensurePrecommit(voteCh, height, round)
 	validatePrecommit(t, cs1, round, 0, vss[0], nil, theBlockHash) // precommit nil but locked on proposal

+	bps5, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	signAddVotes(
 		cs1,
 		tmproto.PrecommitType,
 		propBlock.Hash(),
-		propBlock.MakePartSet(partSize).Header(),
+		bps5.Header(),
 		vs2) // NOTE: conflicting precommits at same height
 	ensurePrecommit(voteCh, height, round)
 }
@@ -631,11 +662,13 @@ func TestStateLockPOLRelock(t *testing.T) {

 	// before we timeout to the new round set the new proposal
 	cs2 := newState(cs1.state, vs2, counter.NewApplication(true))
-	prop, propBlock := decideProposal(cs2, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+
 	propBlockHash := propBlock.Hash()
 	require.NotEqual(t, propBlockHash, theBlockHash)

@@ -728,8 +761,9 @@ func TestStateLockPOLUnlock(t *testing.T) {
 	signAddVotes(cs1, tmproto.PrecommitType, theBlockHash, theBlockParts, vs3)

 	// before we time out into new round, set next proposal block
-	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
-	propBlockParts := propBlock.MakePartSet(partSize)
+	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	// timeout to new round
 	ensureNewTimeout(timeoutWaitCh, height, round, cs1.config.Precommit(round).Nanoseconds())
@@ -816,11 +850,13 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) {

 	// before we timeout to the new round set the new proposal
 	cs2 := newState(cs1.state, vs2, counter.NewApplication(true))
-	prop, propBlock := decideProposal(cs2, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(t, cs2, vs2, vs2.Height, vs2.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
-	secondBlockParts := propBlock.MakePartSet(partSize)
+	secondBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+
 	secondBlockHash := propBlock.Hash()
 	require.NotEqual(t, secondBlockHash, firstBlockHash)

@@ -860,11 +896,12 @@ func TestStateLockPOLUnlockOnUnknownBlock(t *testing.T) {

 	// before we timeout to the new round set the new proposal
 	cs3 := newState(cs1.state, vs3, counter.NewApplication(true))
-	prop, propBlock = decideProposal(cs3, vs3, vs3.Height, vs3.Round+1)
+	prop, propBlock = decideProposal(t, cs3, vs3, vs3.Height, vs3.Round+1)
 	if prop == nil || propBlock == nil {
 		t.Fatal("Failed to create proposal block with vs2")
 	}
-	thirdPropBlockParts := propBlock.MakePartSet(partSize)
+	thirdPropBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
 	thirdPropBlockHash := propBlock.Hash()
 	require.NotEqual(t, secondBlockHash, thirdPropBlockHash)

@@ -928,7 +965,10 @@ func TestStateLockPOLSafety1(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], propBlock.Hash())

 	// the others sign a polka but we don't see it
-	prevotes := signVotes(tmproto.PrevoteType, propBlock.Hash(), propBlock.MakePartSet(partSize).Header(), vs2, vs3, vs4)
+	bps, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+
+	prevotes := signVotes(tmproto.PrevoteType, propBlock.Hash(), bps.Header(), vs2, vs3, vs4)

 	t.Logf("old prop hash %v", fmt.Sprintf("%X", propBlock.Hash()))

@@ -941,9 +981,10 @@ func TestStateLockPOLSafety1(t *testing.T) {

 	t.Log("### ONTO ROUND 1")

-	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
 	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	incrementRound(vs2, vs3, vs4)

@@ -1037,18 +1078,20 @@ func TestStateLockPOLSafety2(t *testing.T) {

 	// the block for R0: gets polkad but we miss it
 	// (even though we signed it, shhh)
-	_, propBlock0 := decideProposal(cs1, vss[0], height, round)
+	_, propBlock0 := decideProposal(t, cs1, vss[0], height, round)
 	propBlockHash0 := propBlock0.Hash()
-	propBlockParts0 := propBlock0.MakePartSet(partSize)
+	propBlockParts0, err := propBlock0.MakePartSet(partSize)
+	require.NoError(t, err)
 	propBlockID0 := types.BlockID{Hash: propBlockHash0, PartSetHeader: propBlockParts0.Header()}

 	// the others sign a polka but we don't see it
 	prevotes := signVotes(tmproto.PrevoteType, propBlockHash0, propBlockParts0.Header(), vs2, vs3, vs4)

 	// the block for round 1
-	prop1, propBlock1 := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
+	prop1, propBlock1 := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
 	propBlockHash1 := propBlock1.Hash()
-	propBlockParts1 := propBlock1.MakePartSet(partSize)
+	propBlockParts1, err := propBlock1.MakePartSet(partSize)
+	require.NoError(t, err)

 	incrementRound(vs2, vs3, vs4)

@@ -1146,7 +1189,9 @@ func TestProposeValidBlock(t *testing.T) {
 	validatePrevote(t, cs1, round, vss[0], propBlockHash)

 	// the others sign a polka
-	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propBlock.MakePartSet(partSize).Header(), vs2, vs3, vs4)
+	bps, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)
+	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, bps.Header(), vs2, vs3, vs4)

 	ensurePrecommit(voteCh, height, round)
 	// we should have precommitted
@@ -1230,7 +1275,8 @@ func TestSetValidBlockOnDelayedPrevote(t *testing.T) {
 	rs := cs1.GetRoundState()
 	propBlock := rs.ProposalBlock
 	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	ensurePrevote(voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], propBlockHash)
@@ -1296,9 +1342,10 @@ func TestSetValidBlockOnDelayedProposal(t *testing.T) {
 	ensurePrevote(voteCh, height, round)
 	validatePrevote(t, cs1, round, vss[0], nil)

-	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round+1)
+	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round+1)
 	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	// vs2, vs3 and vs4 send prevote for propBlock
 	signAddVotes(cs1, tmproto.PrevoteType, propBlockHash, propBlockParts.Header(), vs2, vs3, vs4)
@@ -1456,9 +1503,10 @@ func TestEmitNewValidBlockEventOnCommitWithoutBlock(t *testing.T) {
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)

-	_, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round)
+	_, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round)
 	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	// start round in which PO is not proposer
 	startTestRound(cs1, height, round)
@@ -1489,9 +1537,10 @@ func TestCommitFromPreviousRound(t *testing.T) {
 	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)

-	prop, propBlock := decideProposal(cs1, vs2, vs2.Height, vs2.Round)
+	prop, propBlock := decideProposal(t, cs1, vs2, vs2.Height, vs2.Round)
 	propBlockHash := propBlock.Hash()
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	// start round in which PO is not proposer
 	startTestRound(cs1, height, round)
@@ -1634,8 +1683,9 @@ func TestResetTimeoutPrecommitUponNewHeight(t *testing.T) {

 	ensureNewBlockHeader(newBlockHeader, height, theBlockHash)

-	prop, propBlock := decideProposal(cs1, vs2, height+1, 0)
-	propBlockParts := propBlock.MakePartSet(partSize)
+	prop, propBlock := decideProposal(t, cs1, vs2, height+1, 0)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	if err := cs1.SetProposalAndBlock(prop, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
@@ -1756,7 +1806,8 @@ func TestStateHalt1(t *testing.T) {
 	ensureNewProposal(proposalCh, height, round)
 	rs := cs1.GetRoundState()
 	propBlock := rs.ProposalBlock
-	propBlockParts := propBlock.MakePartSet(partSize)
+	propBlockParts, err := propBlock.MakePartSet(partSize)
+	require.NoError(t, err)

 	ensurePrevote(voteCh, height, round)

@@ -63,6 +63,4 @@ networks:
    ipam:
      driver: default
      config:
-      -
-        subnet: 192.167.10.0/16
-
+        - subnet: 192.167.10.0/16
@@ -148,7 +148,7 @@ func TestAddExpiredEvidence(t *testing.T) {
 func TestReportConflictingVotes(t *testing.T) {
 	var height int64 = 10

-	pool, pv := defaultTestPool(height)
+	pool, pv := defaultTestPool(t, height)
 	val := types.NewValidator(pv.PrivKey.PubKey(), 10)
 	ev := types.NewMockDuplicateVoteEvidenceWithValidator(height+1, defaultEvidenceTime, pv, evidenceChainID)

@@ -182,7 +182,7 @@ func TestReportConflictingVotes(t *testing.T) {

 func TestEvidencePoolUpdate(t *testing.T) {
 	height := int64(21)
-	pool, val := defaultTestPool(height)
+	pool, val := defaultTestPool(t, height)
 	state := pool.State()

 	// create new block (no need to save it to blockStore)
@@ -215,7 +215,7 @@ func TestEvidencePoolUpdate(t *testing.T) {

 func TestVerifyPendingEvidencePasses(t *testing.T) {
 	var height int64 = 1
-	pool, val := defaultTestPool(height)
+	pool, val := defaultTestPool(t, height)
 	ev := types.NewMockDuplicateVoteEvidenceWithValidator(height, defaultEvidenceTime.Add(1*time.Minute),
 		val, evidenceChainID)
 	err := pool.AddEvidence(ev)
@@ -227,7 +227,7 @@ func TestVerifyPendingEvidencePasses(t *testing.T) {

 func TestVerifyDuplicatedEvidenceFails(t *testing.T) {
 	var height int64 = 1
-	pool, val := defaultTestPool(height)
+	pool, val := defaultTestPool(t, height)
 	ev := types.NewMockDuplicateVoteEvidenceWithValidator(height, defaultEvidenceTime.Add(1*time.Minute),
 		val, evidenceChainID)
 	err := pool.CheckEvidence(types.EvidenceList{ev, ev})
@@ -307,7 +307,8 @@ func TestRecoverPendingEvidence(t *testing.T) {
 	stateStore := initializeValidatorState(val, height)
 	state, err := stateStore.Load()
 	require.NoError(t, err)
-	blockStore := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
+	blockStore, err := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
+	require.NoError(t, err)
 	// create previous pool and populate it
 	pool, err := evidence.NewPool(evidenceDB, stateStore, blockStore)
 	require.NoError(t, err)
@@ -399,7 +400,7 @@ func initializeValidatorState(privVal types.PrivValidator, height int64) sm.Stor

 // initializeBlockStore creates a block storage and populates it w/ a dummy
 // block at +height+.
-func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) *store.BlockStore {
+func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) (*store.BlockStore, error) {
 	blockStore := store.NewBlockStore(db)

 	for i := int64(1); i <= state.LastBlockHeight; i++ {
@@ -408,13 +409,16 @@ func initializeBlockStore(db dbm.DB, state sm.State, valAddr []byte) *store.Bloc
 		block.Header.Time = defaultEvidenceTime.Add(time.Duration(i) * time.Minute)
 		block.Header.Version = tmversion.Consensus{Block: version.BlockProtocol, App: 1}
 		const parts = 1
-		partSet := block.MakePartSet(parts)
+		partSet, err := block.MakePartSet(parts)
+		if err != nil {
+			return nil, err
+		}

 		seenCommit := makeCommit(i, valAddr)
 		blockStore.SaveBlock(block, partSet, seenCommit)
 	}

-	return blockStore
+	return blockStore, nil
 }

 func makeCommit(height int64, valAddr []byte) *types.Commit {
@@ -427,13 +431,15 @@ func makeCommit(height int64, valAddr []byte) *types.Commit {
 	return types.NewCommit(height, 0, types.BlockID{}, commitSigs)
 }

-func defaultTestPool(height int64) (*evidence.Pool, types.MockPV) {
+func defaultTestPool(t *testing.T, height int64) (*evidence.Pool, types.MockPV) {
+	t.Helper()
 	val := types.NewMockPV()
 	valAddress := val.PrivKey.PubKey().Address()
 	evidenceDB := dbm.NewMemDB()
 	stateStore := initializeValidatorState(val, height)
 	state, _ := stateStore.Load()
-	blockStore := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
+	blockStore, err := initializeBlockStore(dbm.NewMemDB(), state, valAddress)
+	require.NoError(t, err)
 	pool, err := evidence.NewPool(evidenceDB, stateStore, blockStore)
 	if err != nil {
 		panic("test evidence pool could not be created")
@@ -27,7 +27,7 @@
 //         select {
 //         case msg <- subscription.Out():
 //             // handle msg.Data() and msg.Events()
-//         case <-subscription.Cancelled():
+//         case <-subscription.Canceled():
 //             return subscription.Err()
 //         }
 //     }
@@ -46,7 +46,7 @@ func (s *Subscription) Out() <-chan Message {
 // nolint: misspell
 // Cancelled returns a channel that's closed when the subscription is
 // terminated and supposed to be used in a select statement.
-func (s *Subscription) Cancelled() <-chan struct{} {
+func (s *Subscription) Cancelled() <-chan struct{} { // nolint: misspell
 	return s.canceled
 }

@@ -193,7 +193,7 @@ func (p *http) signedHeader(ctx context.Context, height *int64) (*types.SignedHe
 			time.Sleep(backoffTimeout(uint16(attempt)))
 			continue

-		// either context was cancelled or connection refused.
+		// either context was canceled or connection refused.
 		default:
 			return nil, err
 		}
@@ -23,6 +23,8 @@ const (
 	MaxActiveIDs = math.MaxUint16
 )

+//go:generate mockery --case underscore --name Mempool
+
 // Mempool defines the mempool interface.
 //
 // Updates to the mempool need to be synchronized with committing a block so
@@ -1,43 +0,0 @@
-package mock
-
-import (
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/clist"
-	"github.com/tendermint/tendermint/mempool"
-	"github.com/tendermint/tendermint/types"
-)
-
-// Mempool is an empty implementation of a Mempool, useful for testing.
-type Mempool struct{}
-
-var _ mempool.Mempool = Mempool{}
-
-func (Mempool) Lock()     {}
-func (Mempool) Unlock()   {}
-func (Mempool) Size() int { return 0 }
-func (Mempool) CheckTx(_ types.Tx, _ func(*abci.Response), _ mempool.TxInfo) error {
-	return nil
-}
-func (Mempool) RemoveTxByKey(txKey types.TxKey) error   { return nil }
-func (Mempool) ReapMaxBytesMaxGas(_, _ int64) types.Txs { return types.Txs{} }
-func (Mempool) ReapMaxTxs(n int) types.Txs              { return types.Txs{} }
-func (Mempool) Update(
-	_ int64,
-	_ types.Txs,
-	_ []*abci.ResponseDeliverTx,
-	_ mempool.PreCheckFunc,
-	_ mempool.PostCheckFunc,
-) error {
-	return nil
-}
-func (Mempool) Flush()                        {}
-func (Mempool) FlushAppConn() error           { return nil }
-func (Mempool) TxsAvailable() <-chan struct{} { return make(chan struct{}) }
-func (Mempool) EnableTxsAvailable()           {}
-func (Mempool) SizeBytes() int64              { return 0 }
-
-func (Mempool) TxsFront() *clist.CElement    { return nil }
-func (Mempool) TxsWaitChan() <-chan struct{} { return nil }
-
-func (Mempool) InitWAL() error { return nil }
-func (Mempool) CloseWAL()      {}
@@ -0,0 +1,184 @@
+// Code generated by mockery v2.14.0. DO NOT EDIT.
+
+package mocks
+
+import (
+	abcitypes "github.com/tendermint/tendermint/abci/types"
+	mempool "github.com/tendermint/tendermint/mempool"
+
+	mock "github.com/stretchr/testify/mock"
+
+	types "github.com/tendermint/tendermint/types"
+)
+
+// Mempool is an autogenerated mock type for the Mempool type
+type Mempool struct {
+	mock.Mock
+}
+
+// CheckTx provides a mock function with given fields: tx, callback, txInfo
+func (_m *Mempool) CheckTx(tx types.Tx, callback func(*abcitypes.Response), txInfo mempool.TxInfo) error {
+	ret := _m.Called(tx, callback, txInfo)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(types.Tx, func(*abcitypes.Response), mempool.TxInfo) error); ok {
+		r0 = rf(tx, callback, txInfo)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// EnableTxsAvailable provides a mock function with given fields:
+func (_m *Mempool) EnableTxsAvailable() {
+	_m.Called()
+}
+
+// Flush provides a mock function with given fields:
+func (_m *Mempool) Flush() {
+	_m.Called()
+}
+
+// FlushAppConn provides a mock function with given fields:
+func (_m *Mempool) FlushAppConn() error {
+	ret := _m.Called()
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Lock provides a mock function with given fields:
+func (_m *Mempool) Lock() {
+	_m.Called()
+}
+
+// ReapMaxBytesMaxGas provides a mock function with given fields: maxBytes, maxGas
+func (_m *Mempool) ReapMaxBytesMaxGas(maxBytes int64, maxGas int64) types.Txs {
+	ret := _m.Called(maxBytes, maxGas)
+
+	var r0 types.Txs
+	if rf, ok := ret.Get(0).(func(int64, int64) types.Txs); ok {
+		r0 = rf(maxBytes, maxGas)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Txs)
+		}
+	}
+
+	return r0
+}
+
+// ReapMaxTxs provides a mock function with given fields: max
+func (_m *Mempool) ReapMaxTxs(max int) types.Txs {
+	ret := _m.Called(max)
+
+	var r0 types.Txs
+	if rf, ok := ret.Get(0).(func(int) types.Txs); ok {
+		r0 = rf(max)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(types.Txs)
+		}
+	}
+
+	return r0
+}
+
+// RemoveTxByKey provides a mock function with given fields: txKey
+func (_m *Mempool) RemoveTxByKey(txKey types.TxKey) error {
+	ret := _m.Called(txKey)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(types.TxKey) error); ok {
+		r0 = rf(txKey)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Size provides a mock function with given fields:
+func (_m *Mempool) Size() int {
+	ret := _m.Called()
+
+	var r0 int
+	if rf, ok := ret.Get(0).(func() int); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	return r0
+}
+
+// SizeBytes provides a mock function with given fields:
+func (_m *Mempool) SizeBytes() int64 {
+	ret := _m.Called()
+
+	var r0 int64
+	if rf, ok := ret.Get(0).(func() int64); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	return r0
+}
+
+// TxsAvailable provides a mock function with given fields:
+func (_m *Mempool) TxsAvailable() <-chan struct{} {
+	ret := _m.Called()
+
+	var r0 <-chan struct{}
+	if rf, ok := ret.Get(0).(func() <-chan struct{}); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(<-chan struct{})
+		}
+	}
+
+	return r0
+}
+
+// Unlock provides a mock function with given fields:
+func (_m *Mempool) Unlock() {
+	_m.Called()
+}
+
+// Update provides a mock function with given fields: blockHeight, blockTxs, deliverTxResponses, newPreFn, newPostFn
+func (_m *Mempool) Update(blockHeight int64, blockTxs types.Txs, deliverTxResponses []*abcitypes.ResponseDeliverTx, newPreFn mempool.PreCheckFunc, newPostFn mempool.PostCheckFunc) error {
+	ret := _m.Called(blockHeight, blockTxs, deliverTxResponses, newPreFn, newPostFn)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(int64, types.Txs, []*abcitypes.ResponseDeliverTx, mempool.PreCheckFunc, mempool.PostCheckFunc) error); ok {
+		r0 = rf(blockHeight, blockTxs, deliverTxResponses, newPreFn, newPostFn)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+type mockConstructorTestingTNewMempool interface {
+	mock.TestingT
+	Cleanup(func())
+}
+
+// NewMempool creates a new instance of Mempool. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+func NewMempool(t mockConstructorTestingTNewMempool) *Mempool {
+	mock := &Mempool{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}
@@ -15,4 +15,3 @@
    - config
    - unsafe_reset
    - start
-
@@ -8,4 +8,3 @@
    - service: tendermint
  roles:
    - install
-
@@ -11,4 +11,3 @@
    - JOURNALBEAT_BINARY: "{{lookup('env', 'GOPATH')}}/bin/journalbeat"
  roles:
    - logzio
-
@@ -10,5 +10,3 @@
    - stop
    - unsafe_reset
    - start
-
-
@@ -9,4 +9,3 @@
  roles:
    - stop
    - start
-
@@ -13,5 +13,4 @@
    dest: "/home/{{service}}/.{{service}}/"
    owner: "{{service}}"
    group: "{{service}}"
-  loop: [ 0, 1, 2, 3, 4, 5, 6, 7 ]
-
+  loop: [0, 1, 2, 3, 4, 5, 6, 7]
@@ -2,4 +2,3 @@

 - name: reload services
  systemd: "name={{service}} daemon_reload=yes enabled=yes"
-
@@ -12,4 +12,3 @@
 - name: Create service
  template: "src=systemd.service.j2 dest=/etc/systemd/system/{{service}}.service"
  notify: reload services
-
@@ -5,4 +5,3 @@

 - name: restart journalbeat
  service: name=journalbeat state=restarted
-
@@ -24,4 +24,3 @@
  notify:
  - reload daemon
  - restart journalbeat
-  
@@ -2,4 +2,3 @@

 - name: start service
  service: "name={{service}} state=started"
-
@@ -7,4 +7,3 @@

 - name: Result
  debug: var=status.stdout_lines
-
@@ -2,4 +2,3 @@

 - name: stop service
  service: "name={{service}} state=stopped"
-
@@ -1,4 +1,3 @@
 - command: "{{service}} unsafe_reset_all {{ (service != 'tendermint') | ternary('node','') }} --home /home/{{service}}/.{{service}}"
  become_user: "{{service}}"
  become: yes
-
@@ -8,4 +8,3 @@
    - service: tendermint
  roles:
    - start
-
@@ -8,4 +8,3 @@
    - service: tendermint
  roles:
    - status
-
@@ -8,4 +8,3 @@
    - service: tendermint
  roles:
    - stop
-
@@ -52,7 +52,7 @@ func TestNodeStartStop(t *testing.T) {
 	select {
 	case <-blocksSub.Out():
 	case <-blocksSub.Cancelled():
-		t.Fatal("blocksSub was cancelled")
+		t.Fatal("blocksSub was canceled")
 	case <-time.After(10 * time.Second):
 		t.Fatal("timed out waiting for the node to produce a block")
 	}
@@ -305,14 +305,17 @@ func TestCreateProposalBlock(t *testing.T) {
 	)

 	commit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
-	block, _ := blockExec.CreateProposalBlock(
+	block, err := blockExec.CreateProposalBlock(
 		height,
 		state, commit,
 		proposerAddr,
+		nil,
 	)
+	require.NoError(t, err)

 	// check that the part set does not exceed the maximum block size
-	partSet := block.MakePartSet(partSize)
+	partSet, err := block.MakePartSet(partSize)
+	require.NoError(t, err)
 	assert.Less(t, partSet.ByteSize(), int64(maxBytes))

 	partSetFromHeader := types.NewPartSetFromHeader(partSet.Header())
@@ -383,18 +386,21 @@ func TestMaxProposalBlockSize(t *testing.T) {
 	)

 	commit := types.NewCommit(height-1, 0, types.BlockID{}, nil)
-	block, _ := blockExec.CreateProposalBlock(
+	block, err := blockExec.CreateProposalBlock(
 		height,
 		state, commit,
 		proposerAddr,
+		nil,
 	)
+	require.NoError(t, err)

 	pb, err := block.ToProto()
 	require.NoError(t, err)
 	assert.Less(t, int64(pb.Size()), maxBytes)

 	// check that the part set does not exceed the maximum block size
-	partSet := block.MakePartSet(partSize)
+	partSet, err := block.MakePartSet(partSize)
+	require.NoError(t, err)
 	assert.EqualValues(t, partSet.ByteSize(), int64(pb.Size()))
 }

--- a/Show More
+++ b/Show More