return early if indexer is null

2026-01-12 07:42:48 +00:00 · 2021-12-14 12:33:13 +01:00
754 changed files with 21246 additions and 71677 deletions
--- a/.github/ISSUE_TEMPLATE/proposal.md
+++ b/.github/ISSUE_TEMPLATE/proposal.md
@@ -1,37 +0,0 @@
---
-name: Protocol Change Proposal
-about: Create a proposal to request a change to the protocol
-
---
-
-<!-- < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < ☺ 
-v                            ✰  Thanks for opening an issue! ✰    
-v    Before smashing the submit button please review the template.
-v    Word of caution: Under-specified proposals may be rejected summarily 
-☺ > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >  -->
-
-# Protocol Change Proposal
-
-## Summary
-
-<!-- Short, concise description of the proposed change -->
-
-## Problem Definition
-
-<!-- Why do we need this change? 
-What problems may be addressed by introducing this change?
-What benefits does Tendermint stand to gain by including this change?
-Are there any disadvantages of including this change? -->
-
-## Proposal
-
-<!-- Detailed description of requirements of implementation -->
-
-____
-
-#### For Admin Use
-
- [ ] Not duplicate issue
- [ ] Appropriate labels applied
- [ ] Appropriate contributors tagged
- [ ] Contributor assigned/self-assigned
--- a/.github/auto-comment.yml
+++ b/.github/auto-comment.yml
@@ -1,16 +1,16 @@
 pullRequestOpened: |
-  :wave: Thanks for creating a PR!
+  :wave: Thanks for creating a PR!   

-  Before we can merge this PR, please make sure that all the following items have been
+  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.
+  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
+  - [ ] 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:
+  Thank you for your contribution to Tendermint! :rocket:   
--- a/.github/linter/markdownlint.yml
+++ b/.github/linter/markdownlint.yml
@@ -0,0 +1,8 @@
+default: true,
+MD007: { "indent": 4 }
+MD013: false
+MD024: { siblings_only: true }
+MD025: false
+MD033: { no-inline-html: false }
+no-hard-tabs: false
+whitespace: false
--- a/.github/linters/markdownlint.yml
+++ b/.github/linters/markdownlint.yml
@@ -1,8 +0,0 @@
-default: true,
-MD007: {"indent": 4}
-MD013: false
-MD024: {siblings_only: true}
-MD025: false
-MD033: {no-inline-html: false}
-no-hard-tabs: false
-whitespace: false
--- a/.github/linters/yaml-lint.yml
+++ b/.github/linters/yaml-lint.yml
@@ -1,9 +0,0 @@
---
-# Default rules for YAML linting from super-linter.
-# See: See https://yamllint.readthedocs.io/en/stable/rules.html
-extends: default
-rules:
-  document-end: disable
-  document-start: disable
-  line-length: disable
-  truthy: disable
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -24,7 +24,7 @@ jobs:
        with:
          go-version: "1.17"
      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v6.0.1
+      - uses: technote-space/get-diff-action@v5
        with:
          PATTERNS: |
            **/**.go
@@ -45,7 +45,7 @@ jobs:
        with:
          go-version: "1.17"
      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v6.0.1
+      - uses: technote-space/get-diff-action@v5
        with:
          PATTERNS: |
            **/**.go
@@ -67,7 +67,7 @@ jobs:
        with:
          go-version: "1.17"
      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v6.0.1
+      - uses: technote-space/get-diff-action@v5
        with:
          PATTERNS: |
            **/**.go
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -1,13 +1,13 @@
 name: Docker
-# Build & Push rebuilds the tendermint docker image on every push to master and creation of tags
+#  Build & Push rebuilds the tendermint docker image on every push to master and creation of tags
 # and pushes the image to https://hub.docker.com/r/interchainio/simapp/tags
 on:
  push:
    branches:
      - master
    tags:
-      - "v[0-9]+.[0-9]+.[0-9]+"  # Push events to matching v*, i.e. v1.0, v20.15.10
-      - "v[0-9]+.[0-9]+.[0-9]+-rc*"  # Push events to matching v*, i.e. v1.0-rc1, v20.15.10-rc5
+      - "v[0-9]+.[0-9]+.[0-9]+" # Push events to matching v*, i.e. v1.0, v20.15.10
+      - "v[0-9]+.[0-9]+.[0-9]+-rc*" # Push events to matching v*, i.e. v1.0-rc1, v20.15.10-rc5

 jobs:
  build:
@@ -43,13 +43,13 @@ jobs:

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

      - name: Publish to Docker Hub
-        uses: docker/build-push-action@v2.9.0
+        uses: docker/build-push-action@v2.7.0
        with:
          context: .
          file: ./DOCKER/Dockerfile
--- a/.github/workflows/e2e-manual.yml
+++ b/.github/workflows/e2e-manual.yml
@@ -1,36 +0,0 @@
-# Runs randomly generated E2E testnets nightly on master
-# manually run e2e tests
-name: e2e-manual
-on:
-  workflow_dispatch:
-
-jobs:
-  e2e-nightly-test:
-    # Run parallel jobs for the listed testnet groups (must match the
-    # ./build/generator -g flag)
-    strategy:
-      fail-fast: false
-      matrix:
-        group: ['00', '01', '02', '03']
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    steps:
-      - uses: actions/setup-go@v2
-        with:
-          go-version: '1.17'
-
-      - uses: actions/checkout@v2.4.0
-
-      - name: Build
-        working-directory: test/e2e
-        # Run make jobs in parallel, since we can't run steps in parallel.
-        run: make -j2 docker generator runner tests
-
-      - name: Generate testnets
-        working-directory: test/e2e
-        # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 4 -d networks/nightly/
-
-      - name: Run ${{ matrix.p2p }} p2p testnets
-        working-directory: test/e2e
-        run: ./run-multiple.sh networks/nightly/*-group${{ matrix.group }}-*.toml
--- a/.github/workflows/e2e-nightly-34x.yml
+++ b/.github/workflows/e2e-nightly-34x.yml
@@ -6,6 +6,7 @@

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

@@ -57,3 +58,19 @@ jobs:
          SLACK_COLOR: danger
          SLACK_MESSAGE: Nightly E2E tests failed on v0.34.x
          SLACK_FOOTER: ''
+
+  e2e-nightly-success: # may turn this off once they seem to pass consistently
+    needs: e2e-nightly-test
+    if: ${{ success() }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Notify Slack on success
+        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        env:
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
+          SLACK_CHANNEL: tendermint-internal
+          SLACK_USERNAME: Nightly E2E Tests
+          SLACK_ICON_EMOJI: ':white_check_mark:'
+          SLACK_COLOR: good
+          SLACK_MESSAGE: Nightly E2E tests passed on v0.34.x
+          SLACK_FOOTER: ''
--- a/.github/workflows/e2e-nightly-35x.yml
+++ b/.github/workflows/e2e-nightly-35x.yml
@@ -5,6 +5,7 @@

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

@@ -58,7 +59,7 @@ jobs:
          SLACK_MESSAGE: Nightly E2E tests failed on v0.35.x
          SLACK_FOOTER: ''

-  e2e-nightly-success:  # may turn this off once they seem to pass consistently
+  e2e-nightly-success: # may turn this off once they seem to pass consistently
    needs: e2e-nightly-test
    if: ${{ success() }}
    runs-on: ubuntu-latest
--- a/.github/workflows/e2e-nightly-master.yml
+++ b/.github/workflows/e2e-nightly-master.yml
@@ -5,6 +5,7 @@

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

@@ -55,7 +56,7 @@ jobs:
          SLACK_MESSAGE: Nightly E2E tests failed on master
          SLACK_FOOTER: ''

-  e2e-nightly-success:  # may turn this off once they seem to pass consistently
+  e2e-nightly-success: # may turn this off once they seem to pass consistently
    needs: e2e-nightly-test
    if: ${{ success() }}
    runs-on: ubuntu-latest
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -2,7 +2,7 @@ name: e2e
 # Runs the CI end-to-end test network on all pushes to master or release branches
 # and every pull request, but only if any Go files have been changed.
 on:
-  workflow_dispatch:  # allow running workflow manually
+  workflow_dispatch: # allow running workflow manually
  pull_request:
  push:
    branches:
@@ -18,7 +18,7 @@ jobs:
        with:
          go-version: '1.17'
      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v6.0.1
+      - uses: technote-space/get-diff-action@v5
        with:
          PATTERNS: |
            **/**.go
@@ -35,3 +35,4 @@ jobs:
        working-directory: test/e2e
        run: ./run-multiple.sh networks/ci.toml
        if: "env.GIT_DIFF != ''"
+
--- a/.github/workflows/fuzz-nightly.yml
+++ b/.github/workflows/fuzz-nightly.yml
@@ -1,7 +1,7 @@
 # Runs fuzzing nightly.
 name: Fuzz Tests
 on:
-  workflow_dispatch:  # allow running workflow manually
+  workflow_dispatch: # allow running workflow manually
  schedule:
    - cron: '0 3 * * *'
  pull_request:
--- a/.github/workflows/linkchecker.yml
+++ b/.github/workflows/linkchecker.yml
@@ -1,5 +1,5 @@
 name: Check Markdown links
-on:
+on: 
  schedule:
    - cron: '* */24 * * *'
 jobs:
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -1,4 +1,4 @@
-name: Golang Linter
+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.
@@ -14,7 +14,7 @@ jobs:
    timeout-minutes: 8
    steps:
      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v6.0.1
+      - uses: technote-space/get-diff-action@v5
        with:
          PATTERNS: |
            **/**.go
--- a/.github/workflows/linter.yml
+++ b/.github/workflows/linter.yml
@@ -1,4 +1,4 @@
-name: Markdown Linter
+name: Lint
 on:
  push:
    branches:
@@ -21,12 +21,12 @@ jobs:
      - name: Checkout Code
        uses: actions/checkout@v2.4.0
      - name: Lint Code Base
-        uses: docker://github/super-linter:v4
+        uses: docker://github/super-linter:v3
        env:
+          LINTER_RULES_PATH: .
          VALIDATE_ALL_CODEBASE: true
          DEFAULT_BRANCH: master
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          VALIDATE_MD: true
          VALIDATE_OPENAPI: true
          VALIDATE_YAML: true
-          YAML_CONFIG_FILE: yaml-lint.yml
--- a/.github/workflows/markdown-links.yml
+++ b/.github/workflows/markdown-links.yml
@@ -1,18 +0,0 @@
-# Currently disabled until all links have been fixed
-# name: Check Markdown links
-
-# on:
-#   push:
-#     branches:
-#       - master
-#   pull_request:
-#     branches: [master]
-
-# jobs:
-#   markdown-link-check:
-#     runs-on: ubuntu-latest
-#     steps:
-#     - uses: actions/checkout@master
-#     - uses: gaurav-nelson/github-action-markdown-link-check@1.0.13
-#       with:
-#         check-modified-files-only: 'yes'
--- a/.github/workflows/proto-check.yml
+++ b/.github/workflows/proto-check.yml
@@ -1,24 +0,0 @@
-name: Proto Check
-# Protobuf runs buf (https://buf.build/) lint and check-breakage
-# This workflow is only run when a file in the proto directory
-# has been modified.
-on:
-  workflow_dispatch: # allow running workflow manually
-  pull_request:
-    paths:
-      - "proto/*"
-jobs:
-  proto-lint:
-    runs-on: ubuntu-latest
-    timeout-minutes: 4
-    steps:
-      - uses: actions/checkout@v2.4.0
-      - name: lint
-        run: make proto-lint
-  proto-breakage:
-    runs-on: ubuntu-latest
-    timeout-minutes: 4
-    steps:
-      - uses: actions/checkout@v2.4.0
-      - name: check-breakage
-        run: make proto-check-breaking-ci
--- a/.github/workflows/proto-dockerfile.yml
+++ b/.github/workflows/proto-dockerfile.yml
@@ -1,64 +0,0 @@
-# This workflow (re)builds and pushes a Docker image containing the
-# protobuf build tools used by the other workflows.
-#
-# When making changes that require updates to the builder image, you
-# should merge the updates first and wait for this workflow to complete,
-# so that the changes will be available for the dependent workflows.
-#
-
-name: Build & Push Proto Builder Image
-on:
-  pull_request:
-    paths:
-      - "proto/*"
-  push:
-    branches:
-      - master
-    paths:
-      - "proto/*"
-  schedule:
-    # run this job once a month to recieve any go or buf updates
-    - cron: "0 9 1 * *"
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: tendermint/docker-build-proto
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2.4.0
-      - name: Check out and assign tags
-        id: prep
-        run: |
-          DOCKER_IMAGE="${REGISTRY}/${IMAGE_NAME}"
-          VERSION=noop
-          if [[ "$GITHUB_REF" == "refs/tags/*" ]]; then
-            VERSION="${GITHUB_REF#refs/tags/}"
-          elif [[ "$GITHUB_REF" == "refs/heads/*" ]]; then
-            VERSION="$(echo "${GITHUB_REF#refs/heads/}" | sed -r 's#/+#-#g')"
-            if [[ "${{ github.event.repository.default_branch }}" = "$VERSION" ]]; then
-              VERSION=latest
-            fi
-          fi
-          TAGS="${DOCKER_IMAGE}:${VERSION}"
-          echo ::set-output name=tags::"${TAGS}"
-
-      - name: Set up docker buildx
-        uses: docker/setup-buildx-action@v1.6.0
-
-      - name: Log in to the container registry
-        uses: docker/login-action@v1.12.0
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build and publish image
-        uses: docker/build-push-action@v2.9.0
-        with:
-          context: ./proto
-          file: ./proto/Dockerfile
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.prep.outputs.tags }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -5,7 +5,7 @@ on:
    branches:
      - "RC[0-9]/**"
    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:
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -14,13 +14,13 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        part: ["00", "01", "02", "03", "04", "05"]
+        part: ["00", "01", "02", "03"]
    steps:
      - uses: actions/setup-go@v2
        with:
          go-version: "1.17"
      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v6.0.1
+      - uses: technote-space/get-diff-action@v5
        with:
          PATTERNS: |
            **/**.go
@@ -30,7 +30,7 @@ jobs:
            Makefile
      - name: Run Go Tests
        run: |
-          make test-group-${{ matrix.part }} NUM_SPLIT=6
+          make test-group-${{ matrix.part }} NUM_SPLIT=4
        if: env.GIT_DIFF
      - uses: actions/upload-artifact@v2
        with:
@@ -42,7 +42,7 @@ jobs:
    needs: tests
    steps:
      - uses: actions/checkout@v2.4.0
-      - uses: technote-space/get-diff-action@v6.0.1
+      - uses: technote-space/get-diff-action@v5
        with:
          PATTERNS: |
            **/**.go
--- a/.gitignore
+++ b/.gitignore
@@ -47,11 +47,10 @@ test/fuzz/**/corpus
 test/fuzz/**/crashers
 test/fuzz/**/suppressions
 test/fuzz/**/*.zip
-proto/spec/**/*.pb.go
-*.aux
-*.bbl
-*.blg
-*.log
-*.pdf
-*.gz
-*.dvi
+proto/tendermint/blocksync/types.proto
+proto/tendermint/consensus/types.proto
+proto/tendermint/mempool/*.proto
+proto/tendermint/p2p/*.proto
+proto/tendermint/statesync/*.proto
+proto/tendermint/types/*.proto
+proto/tendermint/version/*.proto
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -29,8 +29,8 @@ release:

 archives:
  - files:
-      - LICENSE
-      - README.md
-      - UPGRADING.md
-      - SECURITY.md
-      - CHANGELOG.md
+    - LICENSE
+    - README.md
+    - UPGRADING.md
+    - SECURITY.md
+    - CHANGELOG.md
--- a/.markdownlint.yml
+++ b/.markdownlint.yml
@@ -1,11 +0,0 @@
-default: true
-MD001: false
-MD007: {indent: 4}
-MD013: false
-MD024: {siblings_only: true}
-MD025: false
-MD033: false
-MD036: false
-MD010: false
-MD012: false
-MD028: false
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,41 +2,6 @@

 Friendly reminder: We have a [bug bounty program](https://hackerone.com/cosmos).

-## v0.35.1
-
-January 26, 2022
-
-Special thanks to external contributors on this release: @altergui, @odeke-em,
-@thanethomson
-
-### BREAKING CHANGES
-
- CLI/RPC/Config
-
-  - [config] [\#7276](https://github.com/tendermint/tendermint/pull/7276) rpc: Add experimental config params to allow for subscription buffer size control (@thanethomson).
-
- P2P Protocol
-
-  - [p2p] [\#7265](https://github.com/tendermint/tendermint/pull/7265) Peer manager reduces peer score for each failed dial attempts for peers that have not successfully dialed. (@tychoish)
-  - [p2p] [\#7594](https://github.com/tendermint/tendermint/pull/7594) always advertise self, to enable mutual address discovery. (@altergui)
-
-### FEATURES
-
- [rpc] [\#7270](https://github.com/tendermint/tendermint/pull/7270) Add `header` and `header_by_hash` RPC Client queries. (@fedekunze) (@cmwaters)
-
-### IMPROVEMENTS
-
- [internal/protoio] [\#7325](https://github.com/tendermint/tendermint/pull/7325) Optimized `MarshalDelimited` by inlining the common case and using a `sync.Pool` in the worst case. (@odeke-em)
- [\#7338](https://github.com/tendermint/tendermint/pull/7338) pubsub: Performance improvements for the event query API (backport of #7319) (@creachadair)
- [\#7252](https://github.com/tendermint/tendermint/pull/7252) Add basic metrics to the indexer package. (@creachadair)
- [\#7338](https://github.com/tendermint/tendermint/pull/7338) Performance improvements for the event query API. (@creachadair)
-
-### BUG FIXES
-
- [\#7310](https://github.com/tendermint/tendermint/issues/7310) pubsub: Report a non-nil error when shutting down (fixes #7306).
- [\#7355](https://github.com/tendermint/tendermint/pull/7355) Fix incorrect tests using the PSQL sink. (@creachadair)
- [\#7683](https://github.com/tendermint/tendermint/pull/7683) rpc: check error code for broadcast_tx_commit. (@tychoish)
-
 ## v0.35.0

 November 4, 2021
@@ -209,21 +174,6 @@ Special thanks to external contributors on this release: @JayT106,
 - [cmd/tendermint/commands] [\#6623](https://github.com/tendermint/tendermint/pull/6623) replace `$HOME/.some/test/dir` with `t.TempDir` (@tanyabouman)
 - [statesync] \6807 Implement P2P state provider as an alternative to RPC (@cmwaters)

-## v0.34.15
-
-Special thanks to external contributors on this release: @thanethomson
-
-### BUG FIXES
-
- [\#7368](https://github.com/tendermint/tendermint/issues/7368) cmd: add integration test for rollback functionality (@cmwaters).
- [\#7309](https://github.com/tendermint/tendermint/issues/7309) pubsub: Report a non-nil error when shutting down (fixes #7306).
- [\#7057](https://github.com/tendermint/tendermint/pull/7057) Import Postgres driver support for the psql indexer (@creachadair).
- [\#7106](https://github.com/tendermint/tendermint/pull/7106) Revert mutex change to ABCI Clients (@tychoish).
-
-### IMPROVEMENTS
-
- [config] [\#7230](https://github.com/tendermint/tendermint/issues/7230) rpc: Add experimental config params to allow for subscription buffer size control (@thanethomson).
-
 ## v0.34.14

 This release backports the `rollback` feature to allow recovery in the event of an incorrect app hash.
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -12,65 +12,42 @@ Special thanks to external contributors on this release:

 - CLI/RPC/Config

-  - [rpc] \#7121 Remove the deprecated gRPC interface to the RPC service. (@creachadair)
+  - [rpc] Remove the deprecated gRPC interface to the RPC service. (@creachadair)
  - [blocksync] \#7159 Remove support for disabling blocksync in any circumstance. (@tychoish)
  - [mempool] \#7171 Remove legacy mempool implementation. (@tychoish)
-  - [rpc] \#7575 Rework how RPC responses are written back via HTTP. (@creachadair)
-  - [rpc] \#7713 Remove unused options for websocket clients. (@creachadair)

 - Apps

-  - [tendermint/spec] \#7804 Migrate spec from [spec repo](https://github.com/tendermint/spec).
+  - [proto/tendermint] \#6976 Remove core protobuf files in favor of only housing them in the [tendermint/spec](https://github.com/tendermint/spec) repository.

 - P2P Protocol

  - [p2p] \#7035 Remove legacy P2P routing implementation and associated configuration options. (@tychoish)
  - [p2p] \#7265 Peer manager reduces peer score for each failed dial attempts for peers that have not successfully dialed. (@tychoish)
-  - [p2p] [\#7594](https://github.com/tendermint/tendermint/pull/7594) always advertise self, to enable mutual address discovery. (@altergui)

 - Go API

-  - [rpc] \#7474 Remove the "URI" RPC client. (@creachadair)
-  - [libs/pubsub] \#7451 Internalize the pubsub packages. (@creachadair)
-  - [libs/sync] \#7450 Internalize and remove the library. (@creachadair)
-  - [libs/async] \#7449 Move library to internal. (@creachadair)
  - [pubsub] \#7231 Remove unbuffered subscriptions and rework the Subscription interface. (@creachadair)
  - [eventbus] \#7231 Move the EventBus type to the internal/eventbus package. (@creachadair)
  - [blocksync] \#7046 Remove v2 implementation of the blocksync service and recactor, which was disabled in the previous release. (@tychoish)
  - [p2p] \#7064 Remove WDRR queue implementation. (@tychoish)
  - [config] \#7169 `WriteConfigFile` now returns an error. (@tychoish)
  - [libs/service] \#7288 Remove SetLogger method on `service.Service` interface. (@tychoish)
-  - [abci/client] \#7607 Simplify client interface (removes most "async" methods). (@creachadair)
-  - [libs/json] \#7673 Remove the libs/json (tmjson) library. (@creachadair)
+

 - Blockchain Protocol

 ### FEATURES

 - [rpc] [\#7270](https://github.com/tendermint/tendermint/pull/7270) Add `header` and `header_by_hash` RPC Client queries. (@fedekunze)
- [rpc] [\#7701] Add `ApplicationInfo` to `status` rpc call which contains the application version. (@jonasbostoen)
 - [cli] [#7033](https://github.com/tendermint/tendermint/pull/7033) Add a `rollback` command to rollback to the previous tendermint state in the event of non-determinstic app hash or reverting an upgrade.
 - [mempool, rpc] \#7041  Add removeTx operation to the RPC layer. (@tychoish)
- [consensus] \#7354 add a new `synchrony` field to the `ConsensusParameter` struct for controlling the parameters of the proposer-based timestamp algorithm. (@williambanfield)
- [consensus] \#7376 Update the proposal logic per the Propose-based timestamps specification so that the proposer will wait for the previous block time to occur before proposing the next block. (@williambanfield)
- [consensus] \#7391 Use the proposed block timestamp as the proposal timestamp. Update the block validation logic to ensure that the proposed block's timestamp matches the timestamp in the proposal message. (@williambanfield)
- [consensus] \#7415 Update proposal validation logic to Prevote nil if a proposal does not meet the conditions for Timelyness per the proposer-based timestamp specification. (@anca)
- [consensus] \#7382 Update block validation to no longer require the block timestamp to be the median of the timestamps of the previous commit. (@anca)
- [consensus] \#7711 Use the proposer timestamp for the first height instead of the genesis time. Chains will still start consensus at the genesis time. (@anca)

 ### IMPROVEMENTS
-
 - [internal/protoio] \#7325 Optimized `MarshalDelimited` by inlining the common case and using a `sync.Pool` in the worst case. (@odeke-em)
- [consensus] \#6969 remove logic to 'unlock' a locked block.
- [evidence] \#7700 Evidence messages contain single Evidence instead of EvidenceList (@jmalicevic)
+
 - [pubsub] \#7319 Performance improvements for the event query API (@creachadair)
- [node] \#7521 Define concrete type for seed node implementation (@spacech1mp)
- [rpc] \#7612 paginate mempool /unconfirmed_txs rpc endpoint (@spacech1mp)
- [light] [\#7536](https://github.com/tendermint/tendermint/pull/7536) rpc /status call returns info about the light client (@jmalicevic)
- [types] \#7765 Replace EvidenceData with EvidenceList to avoid unnecessary nesting of evidence fields within a block. (@jmalicevic)

 ### BUG FIXES

 - fix: assignment copies lock value in `BitArray.UnmarshalJSON()` (@lklimek)
- [light] \#7640 Light Client: fix absence proof verification (@ashcherbakov)
- [light] \#7641 Light Client: fix querying against the latest height (@ashcherbakov)
--- a/DOCKER/Dockerfile
+++ b/DOCKER/Dockerfile
@@ -1,5 +1,5 @@
 # stage 1 Generate Tendermint Binary
-FROM golang:1.17-alpine as builder
+FROM golang:1.16-alpine as builder
 RUN apk update && \
    apk upgrade && \
    apk --no-cache add make
@@ -8,7 +8,7 @@ WORKDIR /tendermint
 RUN make build-linux

 # stage 2
-FROM golang:1.17-alpine
+FROM golang:1.15-alpine
 LABEL maintainer="hello@tendermint.com"

 # Tendermint will be looking for the genesis file in /tendermint/config/genesis.json
--- a/35
+++ b/35
@@ -73,42 +73,22 @@ install:

 $(BUILDDIR)/:
 	mkdir -p $@
-# The Docker image containing the generator, formatter, and linter.
-# This is generated by proto/Dockerfile. To update tools, make changes
-# there and run the Build & Push Proto Builder Image workflow.
-IMAGE := ghcr.io/tendermint/docker-build-proto:latest
-DOCKER_PROTO_BUILDER := docker run -v $(shell pwd):/workspace --workdir /workspace $(IMAGE)
-HTTPS_GIT := https://github.com/tendermint/tendermint.git

 ###############################################################################
 ###                                Protobuf                                 ###
 ###############################################################################

-proto-all: proto-lint proto-check-breaking
-.PHONY: proto-all
-
 proto-gen:
+	@docker pull -q tendermintdev/docker-build-proto
 	@echo "Generating Protobuf files"
-	@$(DOCKER_PROTO_BUILDER) buf generate --template=./buf.gen.yaml --config ./buf.yaml
+	@$(DOCKER_PROTO_BUILDER) sh ./scripts/protocgen.sh
 .PHONY: proto-gen

-proto-lint:
-	@$(DOCKER_PROTO_BUILDER) buf lint --error-format=json --config ./buf.yaml
-.PHONY: proto-lint
-
 proto-format:
 	@echo "Formatting Protobuf files"
-	@$(DOCKER_PROTO_BUILDER) find . -name '*.proto' -path "./proto/*" -exec clang-format -i {} \;
+	@$(DOCKER_PROTO_BUILDER) find ./ -not -path "./third_party/*" -name *.proto -exec clang-format -i {} \;
 .PHONY: proto-format

-proto-check-breaking:
-	@$(DOCKER_PROTO_BUILDER) buf breaking --against .git --config ./buf.yaml
-.PHONY: proto-check-breaking
-
-proto-check-breaking-ci:
-	@$(DOCKER_PROTO_BUILDER) buf breaking --against $(HTTPS_GIT) --config ./buf.yaml
-.PHONY: proto-check-breaking-ci
-
 ###############################################################################
 ###                              Build ABCI                                 ###
 ###############################################################################
@@ -319,14 +299,11 @@ 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).
+# the format statement filters out all packages that don't have tests.
 $(BUILDDIR)/packages.txt:$(GO_TEST_FILES) $(BUILDDIR)
-	go list -f "{{ if (or .TestGoFiles .XTestGoFiles) }}{{ .ImportPath }}{{ end }}" ./... | sort > $@
+	go list -f "{{ if .TestGoFiles }}{{ .ImportPath }}{{ end }}" ./... | sort > $@

 split-test-packages:$(BUILDDIR)/packages.txt
 	split -d -n l/$(NUM_SPLIT) $< $<.
 test-group-%:split-test-packages
-	cat $(BUILDDIR)/packages.txt.$* | xargs go test -mod=readonly -timeout=5m -race -coverprofile=$(BUILDDIR)/$*.profile.out
-
+	cat $(BUILDDIR)/packages.txt.$* | xargs go test -mod=readonly -timeout=8m -race -coverprofile=$(BUILDDIR)/$*.profile.out
--- a/abci/client/client.go
+++ b/abci/client/client.go
@@ -28,24 +28,40 @@ const (
 type Client interface {
 	service.Service

+	SetResponseCallback(Callback)
 	Error() error

-	Flush(context.Context) error
-	Echo(ctx context.Context, msg string) (*types.ResponseEcho, error)
-	Info(context.Context, types.RequestInfo) (*types.ResponseInfo, error)
-	CheckTx(context.Context, types.RequestCheckTx) (*types.ResponseCheckTx, error)
-	Query(context.Context, types.RequestQuery) (*types.ResponseQuery, error)
-	Commit(context.Context) (*types.ResponseCommit, error)
-	InitChain(context.Context, types.RequestInitChain) (*types.ResponseInitChain, error)
-	PrepareProposal(context.Context, types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error)
-	ProcessProposal(context.Context, types.RequestProcessProposal) (*types.ResponseProcessProposal, error)
-	ExtendVote(context.Context, types.RequestExtendVote) (*types.ResponseExtendVote, error)
-	VerifyVoteExtension(context.Context, types.RequestVerifyVoteExtension) (*types.ResponseVerifyVoteExtension, error)
-	FinalizeBlock(context.Context, types.RequestFinalizeBlock) (*types.ResponseFinalizeBlock, error)
-	ListSnapshots(context.Context, types.RequestListSnapshots) (*types.ResponseListSnapshots, error)
-	OfferSnapshot(context.Context, types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)
-	LoadSnapshotChunk(context.Context, types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)
-	ApplySnapshotChunk(context.Context, types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error)
+	// Asynchronous requests
+	FlushAsync(context.Context) (*ReqRes, error)
+	EchoAsync(ctx context.Context, msg string) (*ReqRes, error)
+	InfoAsync(context.Context, types.RequestInfo) (*ReqRes, error)
+	DeliverTxAsync(context.Context, types.RequestDeliverTx) (*ReqRes, error)
+	CheckTxAsync(context.Context, types.RequestCheckTx) (*ReqRes, error)
+	QueryAsync(context.Context, types.RequestQuery) (*ReqRes, error)
+	CommitAsync(context.Context) (*ReqRes, error)
+	InitChainAsync(context.Context, types.RequestInitChain) (*ReqRes, error)
+	BeginBlockAsync(context.Context, types.RequestBeginBlock) (*ReqRes, error)
+	EndBlockAsync(context.Context, types.RequestEndBlock) (*ReqRes, error)
+	ListSnapshotsAsync(context.Context, types.RequestListSnapshots) (*ReqRes, error)
+	OfferSnapshotAsync(context.Context, types.RequestOfferSnapshot) (*ReqRes, error)
+	LoadSnapshotChunkAsync(context.Context, types.RequestLoadSnapshotChunk) (*ReqRes, error)
+	ApplySnapshotChunkAsync(context.Context, types.RequestApplySnapshotChunk) (*ReqRes, error)
+
+	// Synchronous requests
+	FlushSync(context.Context) error
+	EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error)
+	InfoSync(context.Context, types.RequestInfo) (*types.ResponseInfo, error)
+	DeliverTxSync(context.Context, types.RequestDeliverTx) (*types.ResponseDeliverTx, error)
+	CheckTxSync(context.Context, types.RequestCheckTx) (*types.ResponseCheckTx, error)
+	QuerySync(context.Context, types.RequestQuery) (*types.ResponseQuery, error)
+	CommitSync(context.Context) (*types.ResponseCommit, error)
+	InitChainSync(context.Context, types.RequestInitChain) (*types.ResponseInitChain, error)
+	BeginBlockSync(context.Context, types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
+	EndBlockSync(context.Context, types.RequestEndBlock) (*types.ResponseEndBlock, error)
+	ListSnapshotsSync(context.Context, types.RequestListSnapshots) (*types.ResponseListSnapshots, error)
+	OfferSnapshotSync(context.Context, types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error)
+	LoadSnapshotChunkSync(context.Context, types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error)
+	ApplySnapshotChunkSync(context.Context, types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error)
 }

 //----------------------------------------
@@ -64,21 +80,26 @@ func NewClient(logger log.Logger, addr, transport string, mustConnect bool) (cli
 	return
 }

+type Callback func(*types.Request, *types.Response)
+
 type ReqRes struct {
 	*types.Request
+	*sync.WaitGroup
 	*types.Response // Not set atomically, so be sure to use WaitGroup.

-	mtx    sync.Mutex
-	signal chan struct{}
-	cb     func(*types.Response) // A single callback that may be set.
+	mtx  sync.Mutex
+	done bool                  // Gets set to true once *after* WaitGroup.Done().
+	cb   func(*types.Response) // A single callback that may be set.
 }

 func NewReqRes(req *types.Request) *ReqRes {
 	return &ReqRes{
-		Request:  req,
-		Response: nil,
-		signal:   make(chan struct{}),
-		cb:       nil,
+		Request:   req,
+		WaitGroup: waitGroup1(),
+		Response:  nil,
+
+		done: false,
+		cb:   nil,
 	}
 }

@@ -88,14 +109,14 @@ func NewReqRes(req *types.Request) *ReqRes {
 func (r *ReqRes) SetCallback(cb func(res *types.Response)) {
 	r.mtx.Lock()

-	select {
-	case <-r.signal:
+	if r.done {
 		r.mtx.Unlock()
 		cb(r.Response)
-	default:
-		r.cb = cb
-		r.mtx.Unlock()
+		return
 	}
+
+	r.cb = cb
+	r.mtx.Unlock()
 }

 // InvokeCallback invokes a thread-safe execution of the configured callback
@@ -109,10 +130,27 @@ func (r *ReqRes) InvokeCallback() {
 	}
 }

+// GetCallback returns the configured callback of the ReqRes object which may be
+// nil. Note, it is not safe to concurrently call this in cases where it is
+// marked done and SetCallback is called before calling GetCallback as that
+// will invoke the callback twice and create a potential race condition.
+//
+// ref: https://github.com/tendermint/tendermint/issues/5439
+func (r *ReqRes) GetCallback() func(*types.Response) {
+	r.mtx.Lock()
+	defer r.mtx.Unlock()
+	return r.cb
+}
+
 // SetDone marks the ReqRes object as done.
 func (r *ReqRes) SetDone() {
 	r.mtx.Lock()
-	defer r.mtx.Unlock()
-
-	close(r.signal)
+	r.done = true
+	r.mtx.Unlock()
+}
+
+func waitGroup1() (wg *sync.WaitGroup) {
+	wg = &sync.WaitGroup{}
+	wg.Add(1)
+	return
 }
--- a/abci/client/creators.go
+++ b/abci/client/creators.go
@@ -2,6 +2,7 @@ package abciclient

 import (
 	"fmt"
+	"sync"

 	"github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/log"
@@ -13,8 +14,10 @@ type Creator func(log.Logger) (Client, error)
 // NewLocalCreator returns a Creator for the given app,
 // which will be running locally.
 func NewLocalCreator(app types.Application) Creator {
-	return func(logger log.Logger) (Client, error) {
-		return NewLocalClient(logger, app), nil
+	mtx := new(sync.Mutex)
+
+	return func(_ log.Logger) (Client, error) {
+		return NewLocalClient(mtx, app), nil
 	}
 }

--- a/abci/client/grpc_client.go
+++ b/abci/client/grpc_client.go
@@ -2,14 +2,12 @@ package abciclient

 import (
 	"context"
-	"errors"
 	"fmt"
 	"net"
 	"sync"
 	"time"

 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"

 	"github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/log"
@@ -28,9 +26,10 @@ type grpcClient struct {
 	conn     *grpc.ClientConn
 	chReqRes chan *ReqRes // dispatches "async" responses to callbacks *in order*, needed by mempool

-	mtx  sync.Mutex
-	addr string
-	err  error
+	mtx   sync.Mutex
+	addr  string
+	err   error
+	resCb func(*types.Request, *types.Response) // listens to all callbacks
 }

 var _ Client = (*grpcClient)(nil)
@@ -76,9 +75,17 @@ func (cli *grpcClient) OnStart(ctx context.Context) error {
 			defer cli.mtx.Unlock()

 			reqres.SetDone()
+			reqres.Done()
+
+			// Notify client listener if set
+			if cli.resCb != nil {
+				cli.resCb(reqres.Request, reqres.Response)
+			}

 			// Notify reqRes listener if set
-			reqres.InvokeCallback()
+			if cb := reqres.GetCallback(); cb != nil {
+				cb(reqres.Response)
+			}
 		}

 		for {
@@ -98,10 +105,7 @@ func (cli *grpcClient) OnStart(ctx context.Context) error {

 RETRY_LOOP:
 	for {
-		conn, err := grpc.Dial(cli.addr,
-			grpc.WithTransportCredentials(insecure.NewCredentials()),
-			grpc.WithContextDialer(dialerFunc),
-		)
+		conn, err := grpc.Dial(cli.addr, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
 		if err != nil {
 			if cli.mustConnect {
 				return err
@@ -117,14 +121,10 @@ RETRY_LOOP:

 	ENSURE_CONNECTED:
 		for {
-			_, err := client.Echo(ctx, &types.RequestEcho{Message: "hello"}, grpc.WaitForReady(true))
+			_, err := client.Echo(context.Background(), &types.RequestEcho{Message: "hello"}, grpc.WaitForReady(true))
 			if err == nil {
 				break ENSURE_CONNECTED
 			}
-			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-				return err
-			}
-
 			cli.logger.Error("Echo failed", "err", err)
 			time.Sleep(time.Second * echoRetryIntervalSeconds)
 		}
@@ -152,8 +152,10 @@ func (cli *grpcClient) StopForError(err error) {
 	}
 	cli.mtx.Unlock()

-	cli.logger.Error("Stopping abci.grpcClient for error", "err", err)
-	cli.Stop()
+	cli.logger.Error(fmt.Sprintf("Stopping abci.grpcClient for error: %v", err.Error()))
+	if err := cli.Stop(); err != nil {
+		cli.logger.Error("Error stopping abci.grpcClient", "err", err)
+	}
 }

 func (cli *grpcClient) Error() error {
@@ -162,66 +164,353 @@ func (cli *grpcClient) Error() error {
 	return cli.err
 }

+// Set listener for all responses
+// NOTE: callback may get internally generated flush responses.
+func (cli *grpcClient) SetResponseCallback(resCb Callback) {
+	cli.mtx.Lock()
+	cli.resCb = resCb
+	cli.mtx.Unlock()
+}
+
 //----------------------------------------

-func (cli *grpcClient) Flush(ctx context.Context) error { return nil }
-
-func (cli *grpcClient) Echo(ctx context.Context, msg string) (*types.ResponseEcho, error) {
-	return cli.client.Echo(ctx, types.ToRequestEcho(msg).GetEcho(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, error) {
+	req := types.ToRequestEcho(msg)
+	res, err := cli.client.Echo(ctx, req.GetEcho(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Echo{Echo: res}})
 }

-func (cli *grpcClient) Info(ctx context.Context, params types.RequestInfo) (*types.ResponseInfo, error) {
-	return cli.client.Info(ctx, types.ToRequestInfo(params).GetInfo(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) FlushAsync(ctx context.Context) (*ReqRes, error) {
+	req := types.ToRequestFlush()
+	res, err := cli.client.Flush(ctx, req.GetFlush(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Flush{Flush: res}})
 }

-func (cli *grpcClient) CheckTx(ctx context.Context, params types.RequestCheckTx) (*types.ResponseCheckTx, error) {
-	return cli.client.CheckTx(ctx, types.ToRequestCheckTx(params).GetCheckTx(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) InfoAsync(ctx context.Context, params types.RequestInfo) (*ReqRes, error) {
+	req := types.ToRequestInfo(params)
+	res, err := cli.client.Info(ctx, req.GetInfo(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Info{Info: res}})
 }

-func (cli *grpcClient) Query(ctx context.Context, params types.RequestQuery) (*types.ResponseQuery, error) {
-	return cli.client.Query(ctx, types.ToRequestQuery(params).GetQuery(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) DeliverTxAsync(ctx context.Context, params types.RequestDeliverTx) (*ReqRes, error) {
+	req := types.ToRequestDeliverTx(params)
+	res, err := cli.client.DeliverTx(ctx, req.GetDeliverTx(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_DeliverTx{DeliverTx: res}})
 }

-func (cli *grpcClient) Commit(ctx context.Context) (*types.ResponseCommit, error) {
-	return cli.client.Commit(ctx, types.ToRequestCommit().GetCommit(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) CheckTxAsync(ctx context.Context, params types.RequestCheckTx) (*ReqRes, error) {
+	req := types.ToRequestCheckTx(params)
+	res, err := cli.client.CheckTx(ctx, req.GetCheckTx(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_CheckTx{CheckTx: res}})
 }

-func (cli *grpcClient) InitChain(ctx context.Context, params types.RequestInitChain) (*types.ResponseInitChain, error) {
-	return cli.client.InitChain(ctx, types.ToRequestInitChain(params).GetInitChain(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) QueryAsync(ctx context.Context, params types.RequestQuery) (*ReqRes, error) {
+	req := types.ToRequestQuery(params)
+	res, err := cli.client.Query(ctx, req.GetQuery(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Query{Query: res}})
 }

-func (cli *grpcClient) ListSnapshots(ctx context.Context, params types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
-	return cli.client.ListSnapshots(ctx, types.ToRequestListSnapshots(params).GetListSnapshots(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) CommitAsync(ctx context.Context) (*ReqRes, error) {
+	req := types.ToRequestCommit()
+	res, err := cli.client.Commit(ctx, req.GetCommit(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_Commit{Commit: res}})
 }

-func (cli *grpcClient) OfferSnapshot(ctx context.Context, params types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
-	return cli.client.OfferSnapshot(ctx, types.ToRequestOfferSnapshot(params).GetOfferSnapshot(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) InitChainAsync(ctx context.Context, params types.RequestInitChain) (*ReqRes, error) {
+	req := types.ToRequestInitChain(params)
+	res, err := cli.client.InitChain(ctx, req.GetInitChain(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_InitChain{InitChain: res}})
 }

-func (cli *grpcClient) LoadSnapshotChunk(ctx context.Context, params types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
-	return cli.client.LoadSnapshotChunk(ctx, types.ToRequestLoadSnapshotChunk(params).GetLoadSnapshotChunk(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) BeginBlockAsync(ctx context.Context, params types.RequestBeginBlock) (*ReqRes, error) {
+	req := types.ToRequestBeginBlock(params)
+	res, err := cli.client.BeginBlock(ctx, req.GetBeginBlock(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_BeginBlock{BeginBlock: res}})
 }

-func (cli *grpcClient) ApplySnapshotChunk(ctx context.Context, params types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
-	return cli.client.ApplySnapshotChunk(ctx, types.ToRequestApplySnapshotChunk(params).GetApplySnapshotChunk(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) EndBlockAsync(ctx context.Context, params types.RequestEndBlock) (*ReqRes, error) {
+	req := types.ToRequestEndBlock(params)
+	res, err := cli.client.EndBlock(ctx, req.GetEndBlock(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_EndBlock{EndBlock: res}})
 }

-func (cli *grpcClient) PrepareProposal(ctx context.Context, params types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-	return cli.client.PrepareProposal(ctx, types.ToRequestPrepareProposal(params).GetPrepareProposal(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) ListSnapshotsAsync(ctx context.Context, params types.RequestListSnapshots) (*ReqRes, error) {
+	req := types.ToRequestListSnapshots(params)
+	res, err := cli.client.ListSnapshots(ctx, req.GetListSnapshots(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_ListSnapshots{ListSnapshots: res}})
 }

-func (cli *grpcClient) ProcessProposal(ctx context.Context, params types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	return cli.client.ProcessProposal(ctx, types.ToRequestProcessProposal(params).GetProcessProposal(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) OfferSnapshotAsync(ctx context.Context, params types.RequestOfferSnapshot) (*ReqRes, error) {
+	req := types.ToRequestOfferSnapshot(params)
+	res, err := cli.client.OfferSnapshot(ctx, req.GetOfferSnapshot(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_OfferSnapshot{OfferSnapshot: res}})
 }

-func (cli *grpcClient) ExtendVote(ctx context.Context, params types.RequestExtendVote) (*types.ResponseExtendVote, error) {
-	return cli.client.ExtendVote(ctx, types.ToRequestExtendVote(params).GetExtendVote(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) LoadSnapshotChunkAsync(
+	ctx context.Context,
+	params types.RequestLoadSnapshotChunk,
+) (*ReqRes, error) {
+	req := types.ToRequestLoadSnapshotChunk(params)
+	res, err := cli.client.LoadSnapshotChunk(ctx, req.GetLoadSnapshotChunk(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(ctx, req, &types.Response{Value: &types.Response_LoadSnapshotChunk{LoadSnapshotChunk: res}})
 }

-func (cli *grpcClient) VerifyVoteExtension(ctx context.Context, params types.RequestVerifyVoteExtension) (*types.ResponseVerifyVoteExtension, error) {
-	return cli.client.VerifyVoteExtension(ctx, types.ToRequestVerifyVoteExtension(params).GetVerifyVoteExtension(), grpc.WaitForReady(true))
+// NOTE: call is synchronous, use ctx to break early if needed
+func (cli *grpcClient) ApplySnapshotChunkAsync(
+	ctx context.Context,
+	params types.RequestApplySnapshotChunk,
+) (*ReqRes, error) {
+	req := types.ToRequestApplySnapshotChunk(params)
+	res, err := cli.client.ApplySnapshotChunk(ctx, req.GetApplySnapshotChunk(), grpc.WaitForReady(true))
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishAsyncCall(
+		ctx,
+		req,
+		&types.Response{Value: &types.Response_ApplySnapshotChunk{ApplySnapshotChunk: res}},
+	)
 }

-func (cli *grpcClient) FinalizeBlock(ctx context.Context, params types.RequestFinalizeBlock) (*types.ResponseFinalizeBlock, error) {
-	return cli.client.FinalizeBlock(ctx, types.ToRequestFinalizeBlock(params).GetFinalizeBlock(), grpc.WaitForReady(true))
+// finishAsyncCall creates a ReqRes for an async call, and immediately populates it
+// with the response. We don't complete it until it's been ordered via the channel.
+func (cli *grpcClient) finishAsyncCall(ctx context.Context, req *types.Request, res *types.Response) (*ReqRes, error) {
+	reqres := NewReqRes(req)
+	reqres.Response = res
+	select {
+	case cli.chReqRes <- reqres: // use channel for async responses, since they must be ordered
+		return reqres, nil
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+// finishSyncCall waits for an async call to complete. It is necessary to call all
+// sync calls asynchronously as well, to maintain call and response ordering via
+// the channel, and this method will wait until the async call completes.
+func (cli *grpcClient) finishSyncCall(reqres *ReqRes) *types.Response {
+	// It's possible that the callback is called twice, since the callback can
+	// be called immediately on SetCallback() in addition to after it has been
+	// set. This is because completing the ReqRes happens in a separate critical
+	// section from the one where the callback is called: there is a race where
+	// SetCallback() is called between completing the ReqRes and dispatching the
+	// callback.
+	//
+	// We also buffer the channel with 1 response, since SetCallback() will be
+	// called synchronously if the reqres is already completed, in which case
+	// it will block on sending to the channel since it hasn't gotten around to
+	// receiving from it yet.
+	//
+	// ReqRes should really handle callback dispatch internally, to guarantee
+	// that it's only called once and avoid the above race conditions.
+	var once sync.Once
+	ch := make(chan *types.Response, 1)
+	reqres.SetCallback(func(res *types.Response) {
+		once.Do(func() {
+			ch <- res
+		})
+	})
+	return <-ch
+}
+
+//----------------------------------------
+
+func (cli *grpcClient) FlushSync(ctx context.Context) error {
+	return nil
+}
+
+func (cli *grpcClient) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+	reqres, err := cli.EchoAsync(ctx, msg)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetEcho(), cli.Error()
+}
+
+func (cli *grpcClient) InfoSync(
+	ctx context.Context,
+	req types.RequestInfo,
+) (*types.ResponseInfo, error) {
+	reqres, err := cli.InfoAsync(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetInfo(), cli.Error()
+}
+
+func (cli *grpcClient) DeliverTxSync(
+	ctx context.Context,
+	params types.RequestDeliverTx,
+) (*types.ResponseDeliverTx, error) {
+
+	reqres, err := cli.DeliverTxAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetDeliverTx(), cli.Error()
+}
+
+func (cli *grpcClient) CheckTxSync(
+	ctx context.Context,
+	params types.RequestCheckTx,
+) (*types.ResponseCheckTx, error) {
+
+	reqres, err := cli.CheckTxAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetCheckTx(), cli.Error()
+}
+
+func (cli *grpcClient) QuerySync(
+	ctx context.Context,
+	req types.RequestQuery,
+) (*types.ResponseQuery, error) {
+	reqres, err := cli.QueryAsync(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetQuery(), cli.Error()
+}
+
+func (cli *grpcClient) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
+	reqres, err := cli.CommitAsync(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetCommit(), cli.Error()
+}
+
+func (cli *grpcClient) InitChainSync(
+	ctx context.Context,
+	params types.RequestInitChain,
+) (*types.ResponseInitChain, error) {
+
+	reqres, err := cli.InitChainAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetInitChain(), cli.Error()
+}
+
+func (cli *grpcClient) BeginBlockSync(
+	ctx context.Context,
+	params types.RequestBeginBlock,
+) (*types.ResponseBeginBlock, error) {
+
+	reqres, err := cli.BeginBlockAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetBeginBlock(), cli.Error()
+}
+
+func (cli *grpcClient) EndBlockSync(
+	ctx context.Context,
+	params types.RequestEndBlock,
+) (*types.ResponseEndBlock, error) {
+
+	reqres, err := cli.EndBlockAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetEndBlock(), cli.Error()
+}
+
+func (cli *grpcClient) ListSnapshotsSync(
+	ctx context.Context,
+	params types.RequestListSnapshots,
+) (*types.ResponseListSnapshots, error) {
+
+	reqres, err := cli.ListSnapshotsAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetListSnapshots(), cli.Error()
+}
+
+func (cli *grpcClient) OfferSnapshotSync(
+	ctx context.Context,
+	params types.RequestOfferSnapshot,
+) (*types.ResponseOfferSnapshot, error) {
+
+	reqres, err := cli.OfferSnapshotAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetOfferSnapshot(), cli.Error()
+}
+
+func (cli *grpcClient) LoadSnapshotChunkSync(
+	ctx context.Context,
+	params types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
+
+	reqres, err := cli.LoadSnapshotChunkAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetLoadSnapshotChunk(), cli.Error()
+}
+
+func (cli *grpcClient) ApplySnapshotChunkSync(
+	ctx context.Context,
+	params types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
+
+	reqres, err := cli.ApplySnapshotChunkAsync(ctx, params)
+	if err != nil {
+		return nil, err
+	}
+	return cli.finishSyncCall(reqres).GetApplySnapshotChunk(), cli.Error()
 }
--- a/abci/client/local_client.go
+++ b/abci/client/local_client.go
@@ -5,7 +5,6 @@ import (
 	"sync"

 	types "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 )

@@ -16,8 +15,9 @@ import (
 type localClient struct {
 	service.BaseService

-	mtx sync.Mutex
+	mtx *sync.Mutex
 	types.Application
+	Callback
 }

 var _ Client = (*localClient)(nil)
@@ -26,33 +26,196 @@ var _ Client = (*localClient)(nil)
 // methods of the given app.
 //
 // Both Async and Sync methods ignore the given context.Context parameter.
-func NewLocalClient(logger log.Logger, app types.Application) Client {
+func NewLocalClient(mtx *sync.Mutex, app types.Application) Client {
+	if mtx == nil {
+		mtx = new(sync.Mutex)
+	}
 	cli := &localClient{
+		mtx:         mtx,
 		Application: app,
 	}
-	cli.BaseService = *service.NewBaseService(logger, "localClient", cli)
+	cli.BaseService = *service.NewBaseService(nil, "localClient", cli)
 	return cli
 }

 func (*localClient) OnStart(context.Context) error { return nil }
 func (*localClient) OnStop()                       {}

+func (app *localClient) SetResponseCallback(cb Callback) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+	app.Callback = cb
+}
+
 // TODO: change types.Application to include Error()?
 func (app *localClient) Error() error {
 	return nil
 }

+func (app *localClient) FlushAsync(ctx context.Context) (*ReqRes, error) {
+	// Do nothing
+	return newLocalReqRes(types.ToRequestFlush(), nil), nil
+}
+
+func (app *localClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	return app.callback(
+		types.ToRequestEcho(msg),
+		types.ToResponseEcho(msg),
+	), nil
+}
+
+func (app *localClient) InfoAsync(ctx context.Context, req types.RequestInfo) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.Info(req)
+	return app.callback(
+		types.ToRequestInfo(req),
+		types.ToResponseInfo(res),
+	), nil
+}
+
+func (app *localClient) DeliverTxAsync(ctx context.Context, params types.RequestDeliverTx) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.DeliverTx(params)
+	return app.callback(
+		types.ToRequestDeliverTx(params),
+		types.ToResponseDeliverTx(res),
+	), nil
+}
+
+func (app *localClient) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.CheckTx(req)
+	return app.callback(
+		types.ToRequestCheckTx(req),
+		types.ToResponseCheckTx(res),
+	), nil
+}
+
+func (app *localClient) QueryAsync(ctx context.Context, req types.RequestQuery) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.Query(req)
+	return app.callback(
+		types.ToRequestQuery(req),
+		types.ToResponseQuery(res),
+	), nil
+}
+
+func (app *localClient) CommitAsync(ctx context.Context) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.Commit()
+	return app.callback(
+		types.ToRequestCommit(),
+		types.ToResponseCommit(res),
+	), nil
+}
+
+func (app *localClient) InitChainAsync(ctx context.Context, req types.RequestInitChain) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.InitChain(req)
+	return app.callback(
+		types.ToRequestInitChain(req),
+		types.ToResponseInitChain(res),
+	), nil
+}
+
+func (app *localClient) BeginBlockAsync(ctx context.Context, req types.RequestBeginBlock) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.BeginBlock(req)
+	return app.callback(
+		types.ToRequestBeginBlock(req),
+		types.ToResponseBeginBlock(res),
+	), nil
+}
+
+func (app *localClient) EndBlockAsync(ctx context.Context, req types.RequestEndBlock) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.EndBlock(req)
+	return app.callback(
+		types.ToRequestEndBlock(req),
+		types.ToResponseEndBlock(res),
+	), nil
+}
+
+func (app *localClient) ListSnapshotsAsync(ctx context.Context, req types.RequestListSnapshots) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.ListSnapshots(req)
+	return app.callback(
+		types.ToRequestListSnapshots(req),
+		types.ToResponseListSnapshots(res),
+	), nil
+}
+
+func (app *localClient) OfferSnapshotAsync(ctx context.Context, req types.RequestOfferSnapshot) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.OfferSnapshot(req)
+	return app.callback(
+		types.ToRequestOfferSnapshot(req),
+		types.ToResponseOfferSnapshot(res),
+	), nil
+}
+
+func (app *localClient) LoadSnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestLoadSnapshotChunk,
+) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.LoadSnapshotChunk(req)
+	return app.callback(
+		types.ToRequestLoadSnapshotChunk(req),
+		types.ToResponseLoadSnapshotChunk(res),
+	), nil
+}
+
+func (app *localClient) ApplySnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestApplySnapshotChunk,
+) (*ReqRes, error) {
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.ApplySnapshotChunk(req)
+	return app.callback(
+		types.ToRequestApplySnapshotChunk(req),
+		types.ToResponseApplySnapshotChunk(res),
+	), nil
+}
+
 //-------------------------------------------------------

-func (app *localClient) Flush(ctx context.Context) error {
+func (app *localClient) FlushSync(ctx context.Context) error {
 	return nil
 }

-func (app *localClient) Echo(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+func (app *localClient) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
 	return &types.ResponseEcho{Message: msg}, nil
 }

-func (app *localClient) Info(ctx context.Context, req types.RequestInfo) (*types.ResponseInfo, error) {
+func (app *localClient) InfoSync(ctx context.Context, req types.RequestInfo) (*types.ResponseInfo, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()

@@ -60,7 +223,19 @@ func (app *localClient) Info(ctx context.Context, req types.RequestInfo) (*types
 	return &res, nil
 }

-func (app *localClient) CheckTx(
+func (app *localClient) DeliverTxSync(
+	ctx context.Context,
+	req types.RequestDeliverTx,
+) (*types.ResponseDeliverTx, error) {
+
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.DeliverTx(req)
+	return &res, nil
+}
+
+func (app *localClient) CheckTxSync(
 	ctx context.Context,
 	req types.RequestCheckTx,
 ) (*types.ResponseCheckTx, error) {
@@ -71,7 +246,7 @@ func (app *localClient) CheckTx(
 	return &res, nil
 }

-func (app *localClient) Query(
+func (app *localClient) QuerySync(
 	ctx context.Context,
 	req types.RequestQuery,
 ) (*types.ResponseQuery, error) {
@@ -82,7 +257,7 @@ func (app *localClient) Query(
 	return &res, nil
 }

-func (app *localClient) Commit(ctx context.Context) (*types.ResponseCommit, error) {
+func (app *localClient) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()

@@ -90,7 +265,7 @@ func (app *localClient) Commit(ctx context.Context) (*types.ResponseCommit, erro
 	return &res, nil
 }

-func (app *localClient) InitChain(
+func (app *localClient) InitChainSync(
 	ctx context.Context,
 	req types.RequestInitChain,
 ) (*types.ResponseInitChain, error) {
@@ -102,7 +277,31 @@ func (app *localClient) InitChain(
 	return &res, nil
 }

-func (app *localClient) ListSnapshots(
+func (app *localClient) BeginBlockSync(
+	ctx context.Context,
+	req types.RequestBeginBlock,
+) (*types.ResponseBeginBlock, error) {
+
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.BeginBlock(req)
+	return &res, nil
+}
+
+func (app *localClient) EndBlockSync(
+	ctx context.Context,
+	req types.RequestEndBlock,
+) (*types.ResponseEndBlock, error) {
+
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
+
+	res := app.Application.EndBlock(req)
+	return &res, nil
+}
+
+func (app *localClient) ListSnapshotsSync(
 	ctx context.Context,
 	req types.RequestListSnapshots,
 ) (*types.ResponseListSnapshots, error) {
@@ -114,7 +313,7 @@ func (app *localClient) ListSnapshots(
 	return &res, nil
 }

-func (app *localClient) OfferSnapshot(
+func (app *localClient) OfferSnapshotSync(
 	ctx context.Context,
 	req types.RequestOfferSnapshot,
 ) (*types.ResponseOfferSnapshot, error) {
@@ -126,7 +325,7 @@ func (app *localClient) OfferSnapshot(
 	return &res, nil
 }

-func (app *localClient) LoadSnapshotChunk(
+func (app *localClient) LoadSnapshotChunkSync(
 	ctx context.Context,
 	req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {

@@ -137,7 +336,7 @@ func (app *localClient) LoadSnapshotChunk(
 	return &res, nil
 }

-func (app *localClient) ApplySnapshotChunk(
+func (app *localClient) ApplySnapshotChunkSync(
 	ctx context.Context,
 	req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {

@@ -148,57 +347,16 @@ func (app *localClient) ApplySnapshotChunk(
 	return &res, nil
 }

-func (app *localClient) PrepareProposal(
-	ctx context.Context,
-	req types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
+//-------------------------------------------------------

-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.PrepareProposal(req)
-	return &res, nil
+func (app *localClient) callback(req *types.Request, res *types.Response) *ReqRes {
+	app.Callback(req, res)
+	return newLocalReqRes(req, res)
 }

-func (app *localClient) ProcessProposal(
-	ctx context.Context,
-	req types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.ProcessProposal(req)
-	return &res, nil
-}
-
-func (app *localClient) ExtendVote(
-	ctx context.Context,
-	req types.RequestExtendVote) (*types.ResponseExtendVote, error) {
-
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.ExtendVote(req)
-	return &res, nil
-}
-
-func (app *localClient) VerifyVoteExtension(
-	ctx context.Context,
-	req types.RequestVerifyVoteExtension) (*types.ResponseVerifyVoteExtension, error) {
-
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.VerifyVoteExtension(req)
-	return &res, nil
-}
-
-func (app *localClient) FinalizeBlock(
-	ctx context.Context,
-	req types.RequestFinalizeBlock) (*types.ResponseFinalizeBlock, error) {
-
-	app.mtx.Lock()
-	defer app.mtx.Unlock()
-
-	res := app.Application.FinalizeBlock(req)
-	return &res, nil
+func newLocalReqRes(req *types.Request, res *types.Response) *ReqRes {
+	reqRes := NewReqRes(req)
+	reqRes.Response = res
+	reqRes.SetDone()
+	return reqRes
 }
--- a/abci/client/mocks/client.go
+++ b/abci/client/mocks/client.go
@@ -17,8 +17,31 @@ type Client struct {
 	mock.Mock
 }

-// ApplySnapshotChunk provides a mock function with given fields: _a0, _a1
-func (_m *Client) ApplySnapshotChunk(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
+// ApplySnapshotChunkAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ApplySnapshotChunkAsync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestApplySnapshotChunk) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ApplySnapshotChunkSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ApplySnapshotChunkSync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
 	ret := _m.Called(_a0, _a1)

 	var r0 *types.ResponseApplySnapshotChunk
@@ -40,21 +63,44 @@ func (_m *Client) ApplySnapshotChunk(_a0 context.Context, _a1 types.RequestApply
 	return r0, r1
 }

-// CheckTx provides a mock function with given fields: _a0, _a1
-func (_m *Client) CheckTx(_a0 context.Context, _a1 types.RequestCheckTx) (*types.ResponseCheckTx, error) {
+// BeginBlockAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) BeginBlockAsync(_a0 context.Context, _a1 types.RequestBeginBlock) (*abciclient.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)

-	var r0 *types.ResponseCheckTx
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *types.ResponseCheckTx); ok {
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *abciclient.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseCheckTx)
+			r0 = ret.Get(0).(*abciclient.ReqRes)
 		}
 	}

 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, types.RequestCheckTx) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestBeginBlock) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// BeginBlockSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) BeginBlockSync(_a0 context.Context, _a1 types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *types.ResponseBeginBlock
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *types.ResponseBeginBlock); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseBeginBlock)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestBeginBlock) error); ok {
 		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
@@ -86,8 +132,54 @@ func (_m *Client) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*
 	return r0, r1
 }

-// Commit provides a mock function with given fields: _a0
-func (_m *Client) Commit(_a0 context.Context) (*types.ResponseCommit, error) {
+// CheckTxSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) CheckTxSync(_a0 context.Context, _a1 types.RequestCheckTx) (*types.ResponseCheckTx, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *types.ResponseCheckTx
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *types.ResponseCheckTx); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseCheckTx)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestCheckTx) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CommitAsync provides a mock function with given fields: _a0
+func (_m *Client) CommitAsync(_a0 context.Context) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context) *abciclient.ReqRes); ok {
+		r0 = rf(_a0)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(_a0)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// CommitSync provides a mock function with given fields: _a0
+func (_m *Client) CommitSync(_a0 context.Context) (*types.ResponseCommit, error) {
 	ret := _m.Called(_a0)

 	var r0 *types.ResponseCommit
@@ -109,8 +201,77 @@ func (_m *Client) Commit(_a0 context.Context) (*types.ResponseCommit, error) {
 	return r0, r1
 }

-// Echo provides a mock function with given fields: ctx, msg
-func (_m *Client) Echo(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+// DeliverTxAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestDeliverTx) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DeliverTxSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) DeliverTxSync(_a0 context.Context, _a1 types.RequestDeliverTx) (*types.ResponseDeliverTx, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *types.ResponseDeliverTx
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *types.ResponseDeliverTx); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseDeliverTx)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestDeliverTx) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// EchoAsync provides a mock function with given fields: ctx, msg
+func (_m *Client) EchoAsync(ctx context.Context, msg string) (*abciclient.ReqRes, error) {
+	ret := _m.Called(ctx, msg)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, string) *abciclient.ReqRes); ok {
+		r0 = rf(ctx, msg)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
+		r1 = rf(ctx, msg)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// EchoSync provides a mock function with given fields: ctx, msg
+func (_m *Client) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
 	ret := _m.Called(ctx, msg)

 	var r0 *types.ResponseEcho
@@ -132,6 +293,52 @@ func (_m *Client) Echo(ctx context.Context, msg string) (*types.ResponseEcho, er
 	return r0, r1
 }

+// EndBlockAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) EndBlockAsync(_a0 context.Context, _a1 types.RequestEndBlock) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestEndBlock) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// EndBlockSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) EndBlockSync(_a0 context.Context, _a1 types.RequestEndBlock) (*types.ResponseEndBlock, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *types.ResponseEndBlock
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *types.ResponseEndBlock); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*types.ResponseEndBlock)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestEndBlock) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // Error provides a mock function with given fields:
 func (_m *Client) Error() error {
 	ret := _m.Called()
@@ -146,22 +353,22 @@ func (_m *Client) Error() error {
 	return r0
 }

-// ExtendVote provides a mock function with given fields: _a0, _a1
-func (_m *Client) ExtendVote(_a0 context.Context, _a1 types.RequestExtendVote) (*types.ResponseExtendVote, error) {
-	ret := _m.Called(_a0, _a1)
+// FlushAsync provides a mock function with given fields: _a0
+func (_m *Client) FlushAsync(_a0 context.Context) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0)

-	var r0 *types.ResponseExtendVote
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestExtendVote) *types.ResponseExtendVote); ok {
-		r0 = rf(_a0, _a1)
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context) *abciclient.ReqRes); ok {
+		r0 = rf(_a0)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseExtendVote)
+			r0 = ret.Get(0).(*abciclient.ReqRes)
 		}
 	}

 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, types.RequestExtendVote) error); ok {
-		r1 = rf(_a0, _a1)
+	if rf, ok := ret.Get(1).(func(context.Context) error); ok {
+		r1 = rf(_a0)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -169,31 +376,8 @@ func (_m *Client) ExtendVote(_a0 context.Context, _a1 types.RequestExtendVote) (
 	return r0, r1
 }

-// FinalizeBlock provides a mock function with given fields: _a0, _a1
-func (_m *Client) FinalizeBlock(_a0 context.Context, _a1 types.RequestFinalizeBlock) (*types.ResponseFinalizeBlock, error) {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 *types.ResponseFinalizeBlock
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestFinalizeBlock) *types.ResponseFinalizeBlock); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseFinalizeBlock)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, types.RequestFinalizeBlock) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Flush provides a mock function with given fields: _a0
-func (_m *Client) Flush(_a0 context.Context) error {
+// FlushSync provides a mock function with given fields: _a0
+func (_m *Client) FlushSync(_a0 context.Context) error {
 	ret := _m.Called(_a0)

 	var r0 error
@@ -206,8 +390,31 @@ func (_m *Client) Flush(_a0 context.Context) error {
 	return r0
 }

-// Info provides a mock function with given fields: _a0, _a1
-func (_m *Client) Info(_a0 context.Context, _a1 types.RequestInfo) (*types.ResponseInfo, error) {
+// InfoAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InfoAsync(_a0 context.Context, _a1 types.RequestInfo) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestInfo) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InfoSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InfoSync(_a0 context.Context, _a1 types.RequestInfo) (*types.ResponseInfo, error) {
 	ret := _m.Called(_a0, _a1)

 	var r0 *types.ResponseInfo
@@ -229,8 +436,31 @@ func (_m *Client) Info(_a0 context.Context, _a1 types.RequestInfo) (*types.Respo
 	return r0, r1
 }

-// InitChain provides a mock function with given fields: _a0, _a1
-func (_m *Client) InitChain(_a0 context.Context, _a1 types.RequestInitChain) (*types.ResponseInitChain, error) {
+// InitChainAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InitChainAsync(_a0 context.Context, _a1 types.RequestInitChain) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestInitChain) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// InitChainSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) InitChainSync(_a0 context.Context, _a1 types.RequestInitChain) (*types.ResponseInitChain, error) {
 	ret := _m.Called(_a0, _a1)

 	var r0 *types.ResponseInitChain
@@ -266,8 +496,31 @@ func (_m *Client) IsRunning() bool {
 	return r0
 }

-// ListSnapshots provides a mock function with given fields: _a0, _a1
-func (_m *Client) ListSnapshots(_a0 context.Context, _a1 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
+// ListSnapshotsAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ListSnapshotsAsync(_a0 context.Context, _a1 types.RequestListSnapshots) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestListSnapshots) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ListSnapshotsSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) ListSnapshotsSync(_a0 context.Context, _a1 types.RequestListSnapshots) (*types.ResponseListSnapshots, error) {
 	ret := _m.Called(_a0, _a1)

 	var r0 *types.ResponseListSnapshots
@@ -289,8 +542,31 @@ func (_m *Client) ListSnapshots(_a0 context.Context, _a1 types.RequestListSnapsh
 	return r0, r1
 }

-// LoadSnapshotChunk provides a mock function with given fields: _a0, _a1
-func (_m *Client) LoadSnapshotChunk(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
+// LoadSnapshotChunkAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) LoadSnapshotChunkAsync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestLoadSnapshotChunk) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// LoadSnapshotChunkSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) LoadSnapshotChunkSync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
 	ret := _m.Called(_a0, _a1)

 	var r0 *types.ResponseLoadSnapshotChunk
@@ -312,8 +588,31 @@ func (_m *Client) LoadSnapshotChunk(_a0 context.Context, _a1 types.RequestLoadSn
 	return r0, r1
 }

-// OfferSnapshot provides a mock function with given fields: _a0, _a1
-func (_m *Client) OfferSnapshot(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
+// OfferSnapshotAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) OfferSnapshotAsync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*abciclient.ReqRes, error) {
+	ret := _m.Called(_a0, _a1)
+
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *abciclient.ReqRes); ok {
+		r0 = rf(_a0, _a1)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*abciclient.ReqRes)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestOfferSnapshot) error); ok {
+		r1 = rf(_a0, _a1)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// OfferSnapshotSync provides a mock function with given fields: _a0, _a1
+func (_m *Client) OfferSnapshotSync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*types.ResponseOfferSnapshot, error) {
 	ret := _m.Called(_a0, _a1)

 	var r0 *types.ResponseOfferSnapshot
@@ -335,21 +634,21 @@ func (_m *Client) OfferSnapshot(_a0 context.Context, _a1 types.RequestOfferSnaps
 	return r0, r1
 }

-// PrepareProposal provides a mock function with given fields: _a0, _a1
-func (_m *Client) PrepareProposal(_a0 context.Context, _a1 types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
+// QueryAsync provides a mock function with given fields: _a0, _a1
+func (_m *Client) QueryAsync(_a0 context.Context, _a1 types.RequestQuery) (*abciclient.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)

-	var r0 *types.ResponsePrepareProposal
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestPrepareProposal) *types.ResponsePrepareProposal); ok {
+	var r0 *abciclient.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *abciclient.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponsePrepareProposal)
+			r0 = ret.Get(0).(*abciclient.ReqRes)
 		}
 	}

 	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, types.RequestPrepareProposal) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, types.RequestQuery) error); ok {
 		r1 = rf(_a0, _a1)
 	} else {
 		r1 = ret.Error(1)
@@ -358,31 +657,8 @@ func (_m *Client) PrepareProposal(_a0 context.Context, _a1 types.RequestPrepareP
 	return r0, r1
 }

-// ProcessProposal provides a mock function with given fields: _a0, _a1
-func (_m *Client) ProcessProposal(_a0 context.Context, _a1 types.RequestProcessProposal) (*types.ResponseProcessProposal, error) {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 *types.ResponseProcessProposal
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestProcessProposal) *types.ResponseProcessProposal); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseProcessProposal)
-		}
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, types.RequestProcessProposal) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Query provides a mock function with given fields: _a0, _a1
-func (_m *Client) Query(_a0 context.Context, _a1 types.RequestQuery) (*types.ResponseQuery, error) {
+// QuerySync provides a mock function with given fields: _a0, _a1
+func (_m *Client) QuerySync(_a0 context.Context, _a1 types.RequestQuery) (*types.ResponseQuery, error) {
 	ret := _m.Called(_a0, _a1)

 	var r0 *types.ResponseQuery
@@ -404,6 +680,11 @@ func (_m *Client) Query(_a0 context.Context, _a1 types.RequestQuery) (*types.Res
 	return r0, r1
 }

+// SetResponseCallback provides a mock function with given fields: _a0
+func (_m *Client) SetResponseCallback(_a0 abciclient.Callback) {
+	_m.Called(_a0)
+}
+
 // Start provides a mock function with given fields: _a0
 func (_m *Client) Start(_a0 context.Context) error {
 	ret := _m.Called(_a0)
@@ -418,27 +699,18 @@ func (_m *Client) Start(_a0 context.Context) error {
 	return r0
 }

-// VerifyVoteExtension provides a mock function with given fields: _a0, _a1
-func (_m *Client) VerifyVoteExtension(_a0 context.Context, _a1 types.RequestVerifyVoteExtension) (*types.ResponseVerifyVoteExtension, error) {
-	ret := _m.Called(_a0, _a1)
+// String provides a mock function with given fields:
+func (_m *Client) String() string {
+	ret := _m.Called()

-	var r0 *types.ResponseVerifyVoteExtension
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestVerifyVoteExtension) *types.ResponseVerifyVoteExtension); ok {
-		r0 = rf(_a0, _a1)
+	var r0 string
+	if rf, ok := ret.Get(0).(func() string); ok {
+		r0 = rf()
 	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.ResponseVerifyVoteExtension)
-		}
+		r0 = ret.Get(0).(string)
 	}

-	var r1 error
-	if rf, ok := ret.Get(1).(func(context.Context, types.RequestVerifyVoteExtension) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
+	return r0
 }

 // Wait provides a mock function with given fields:
--- a/abci/client/socket_client.go
+++ b/abci/client/socket_client.go
@@ -24,6 +24,11 @@ const (
 	reqQueueSize = 256
 )

+type reqResWithContext struct {
+	R *ReqRes
+	C context.Context // if context.Err is not nil, reqRes will be thrown away (ignored)
+}
+
 // This is goroutine-safe, but users should beware that the application in
 // general is not meant to be interfaced with concurrent callers.
 type socketClient struct {
@@ -34,7 +39,7 @@ type socketClient struct {
 	mustConnect bool
 	conn        net.Conn

-	reqQueue chan *ReqRes
+	reqQueue chan *reqResWithContext

 	mtx     sync.Mutex
 	err     error
@@ -50,7 +55,7 @@ var _ Client = (*socketClient)(nil)
 func NewSocketClient(logger log.Logger, addr string, mustConnect bool) Client {
 	cli := &socketClient{
 		logger:      logger,
-		reqQueue:    make(chan *ReqRes, reqQueueSize),
+		reqQueue:    make(chan *reqResWithContext, reqQueueSize),
 		mustConnect: mustConnect,
 		addr:        addr,
 		reqSent:     list.New(),
@@ -94,10 +99,7 @@ func (cli *socketClient) OnStop() {
 		cli.conn.Close()
 	}

-	// this timeout is arbitrary.
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-	cli.drainQueue(ctx)
+	cli.drainQueue()
 }

 // Error returns an error if the client was stopped abruptly.
@@ -107,6 +109,16 @@ func (cli *socketClient) Error() error {
 	return cli.err
 }

+// SetResponseCallback sets a callback, which will be executed for each
+// non-error & non-empty response from the server.
+//
+// NOTE: callback may get internally generated flush responses.
+func (cli *socketClient) SetResponseCallback(resCb Callback) {
+	cli.mtx.Lock()
+	defer cli.mtx.Unlock()
+	cli.resCb = resCb
+}
+
 //----------------------------------------

 func (cli *socketClient) sendRequestsRoutine(ctx context.Context, conn io.Writer) {
@@ -120,9 +132,13 @@ func (cli *socketClient) sendRequestsRoutine(ctx context.Context, conn io.Writer
 				return
 			}

-			cli.willSendReq(reqres)
+			if reqres.C.Err() != nil {
+				cli.logger.Debug("Request's context is done", "req", reqres.R, "err", reqres.C.Err())
+				continue
+			}
+			cli.willSendReq(reqres.R)

-			if err := types.WriteMessage(reqres.Request, bw); err != nil {
+			if err := types.WriteMessage(reqres.R.Request, bw); err != nil {
 				cli.stopForError(fmt.Errorf("write to buffer: %w", err))
 				return
 			}
@@ -187,7 +203,7 @@ func (cli *socketClient) didRecvResponse(res *types.Response) error {
 	}

 	reqres.Response = res
-	reqres.SetDone()         // release waiters
+	reqres.Done()            // release waiters
 	cli.reqSent.Remove(next) // pop first item from linked list

 	// Notify client listener if set (global callback).
@@ -206,8 +222,72 @@ func (cli *socketClient) didRecvResponse(res *types.Response) error {

 //----------------------------------------

-func (cli *socketClient) Flush(ctx context.Context) error {
-	reqRes, err := cli.queueRequest(ctx, types.ToRequestFlush())
+func (cli *socketClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestEcho(msg))
+}
+
+func (cli *socketClient) FlushAsync(ctx context.Context) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestFlush())
+}
+
+func (cli *socketClient) InfoAsync(ctx context.Context, req types.RequestInfo) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestInfo(req))
+}
+
+func (cli *socketClient) DeliverTxAsync(ctx context.Context, req types.RequestDeliverTx) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestDeliverTx(req))
+}
+
+func (cli *socketClient) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestCheckTx(req))
+}
+
+func (cli *socketClient) QueryAsync(ctx context.Context, req types.RequestQuery) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestQuery(req))
+}
+
+func (cli *socketClient) CommitAsync(ctx context.Context) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestCommit())
+}
+
+func (cli *socketClient) InitChainAsync(ctx context.Context, req types.RequestInitChain) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestInitChain(req))
+}
+
+func (cli *socketClient) BeginBlockAsync(ctx context.Context, req types.RequestBeginBlock) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestBeginBlock(req))
+}
+
+func (cli *socketClient) EndBlockAsync(ctx context.Context, req types.RequestEndBlock) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestEndBlock(req))
+}
+
+func (cli *socketClient) ListSnapshotsAsync(ctx context.Context, req types.RequestListSnapshots) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestListSnapshots(req))
+}
+
+func (cli *socketClient) OfferSnapshotAsync(ctx context.Context, req types.RequestOfferSnapshot) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestOfferSnapshot(req))
+}
+
+func (cli *socketClient) LoadSnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestLoadSnapshotChunk,
+) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestLoadSnapshotChunk(req))
+}
+
+func (cli *socketClient) ApplySnapshotChunkAsync(
+	ctx context.Context,
+	req types.RequestApplySnapshotChunk,
+) (*ReqRes, error) {
+	return cli.queueRequestAsync(ctx, types.ToRequestApplySnapshotChunk(req))
+}
+
+//----------------------------------------
+
+func (cli *socketClient) FlushSync(ctx context.Context) error {
+	reqRes, err := cli.queueRequest(ctx, types.ToRequestFlush(), true)
 	if err != nil {
 		return queueErr(err)
 	}
@@ -216,211 +296,218 @@ func (cli *socketClient) Flush(ctx context.Context) error {
 		return err
 	}

+	gotResp := make(chan struct{})
+	go func() {
+		// NOTE: if we don't flush the queue, its possible to get stuck here
+		reqRes.Wait()
+		close(gotResp)
+	}()
+
 	select {
-	case <-reqRes.signal:
+	case <-gotResp:
 		return cli.Error()
 	case <-ctx.Done():
 		return ctx.Err()
 	}
 }

-func (cli *socketClient) Echo(ctx context.Context, msg string) (*types.ResponseEcho, error) {
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestEcho(msg))
+func (cli *socketClient) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestEcho(msg))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetEcho(), nil
 }

-func (cli *socketClient) Info(
+func (cli *socketClient) InfoSync(
 	ctx context.Context,
 	req types.RequestInfo,
 ) (*types.ResponseInfo, error) {
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestInfo(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestInfo(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetInfo(), nil
 }

-func (cli *socketClient) CheckTx(
+func (cli *socketClient) DeliverTxSync(
+	ctx context.Context,
+	req types.RequestDeliverTx,
+) (*types.ResponseDeliverTx, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestDeliverTx(req))
+	if err != nil {
+		return nil, err
+	}
+	return reqres.Response.GetDeliverTx(), nil
+}
+
+func (cli *socketClient) CheckTxSync(
 	ctx context.Context,
 	req types.RequestCheckTx,
 ) (*types.ResponseCheckTx, error) {
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestCheckTx(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestCheckTx(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetCheckTx(), nil
 }

-func (cli *socketClient) Query(
+func (cli *socketClient) QuerySync(
 	ctx context.Context,
 	req types.RequestQuery,
 ) (*types.ResponseQuery, error) {
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestQuery(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestQuery(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetQuery(), nil
 }

-func (cli *socketClient) Commit(ctx context.Context) (*types.ResponseCommit, error) {
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestCommit())
+func (cli *socketClient) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestCommit())
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetCommit(), nil
 }

-func (cli *socketClient) InitChain(
+func (cli *socketClient) InitChainSync(
 	ctx context.Context,
 	req types.RequestInitChain,
 ) (*types.ResponseInitChain, error) {

-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestInitChain(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestInitChain(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetInitChain(), nil
 }

-func (cli *socketClient) ListSnapshots(
+func (cli *socketClient) BeginBlockSync(
+	ctx context.Context,
+	req types.RequestBeginBlock,
+) (*types.ResponseBeginBlock, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestBeginBlock(req))
+	if err != nil {
+		return nil, err
+	}
+	return reqres.Response.GetBeginBlock(), nil
+}
+
+func (cli *socketClient) EndBlockSync(
+	ctx context.Context,
+	req types.RequestEndBlock,
+) (*types.ResponseEndBlock, error) {
+
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestEndBlock(req))
+	if err != nil {
+		return nil, err
+	}
+	return reqres.Response.GetEndBlock(), nil
+}
+
+func (cli *socketClient) ListSnapshotsSync(
 	ctx context.Context,
 	req types.RequestListSnapshots,
 ) (*types.ResponseListSnapshots, error) {

-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestListSnapshots(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestListSnapshots(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetListSnapshots(), nil
 }

-func (cli *socketClient) OfferSnapshot(
+func (cli *socketClient) OfferSnapshotSync(
 	ctx context.Context,
 	req types.RequestOfferSnapshot,
 ) (*types.ResponseOfferSnapshot, error) {

-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestOfferSnapshot(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestOfferSnapshot(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetOfferSnapshot(), nil
 }

-func (cli *socketClient) LoadSnapshotChunk(
+func (cli *socketClient) LoadSnapshotChunkSync(
 	ctx context.Context,
 	req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {

-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestLoadSnapshotChunk(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestLoadSnapshotChunk(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetLoadSnapshotChunk(), nil
 }

-func (cli *socketClient) ApplySnapshotChunk(
+func (cli *socketClient) ApplySnapshotChunkSync(
 	ctx context.Context,
 	req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {

-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestApplySnapshotChunk(req))
+	reqres, err := cli.queueRequestAndFlushSync(ctx, types.ToRequestApplySnapshotChunk(req))
 	if err != nil {
 		return nil, err
 	}
 	return reqres.Response.GetApplySnapshotChunk(), nil
 }

-func (cli *socketClient) PrepareProposal(
-	ctx context.Context,
-	req types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
-
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestPrepareProposal(req))
-	if err != nil {
-		return nil, err
-	}
-	return reqres.Response.GetPrepareProposal(), nil
-}
-
-func (cli *socketClient) ProcessProposal(
-	ctx context.Context,
-	req types.RequestProcessProposal,
-) (*types.ResponseProcessProposal, error) {
-
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestProcessProposal(req))
-	if err != nil {
-		return nil, err
-	}
-	return reqres.Response.GetProcessProposal(), nil
-}
-
-func (cli *socketClient) ExtendVote(
-	ctx context.Context,
-	req types.RequestExtendVote) (*types.ResponseExtendVote, error) {
-
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestExtendVote(req))
-	if err != nil {
-		return nil, err
-	}
-	return reqres.Response.GetExtendVote(), nil
-}
-
-func (cli *socketClient) VerifyVoteExtension(
-	ctx context.Context,
-	req types.RequestVerifyVoteExtension) (*types.ResponseVerifyVoteExtension, error) {
-
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestVerifyVoteExtension(req))
-	if err != nil {
-		return nil, err
-	}
-	return reqres.Response.GetVerifyVoteExtension(), nil
-}
-
-func (cli *socketClient) FinalizeBlock(
-	ctx context.Context,
-	req types.RequestFinalizeBlock) (*types.ResponseFinalizeBlock, error) {
-
-	reqres, err := cli.queueRequestAndFlush(ctx, types.ToRequestFinalizeBlock(req))
-	if err != nil {
-		return nil, err
-	}
-	return reqres.Response.GetFinalizeBlock(), nil
-}
-
 //----------------------------------------

-// queueRequest enqueues req onto the queue. The request can break early if the
-// the context is canceled. If the queue is full, this method blocks to allow
-// the request to be placed onto the queue. This has the effect of creating an
-// unbounded queue of goroutines waiting to write to this queue which is a bit
-// antithetical to the purposes of a queue, however, undoing this behavior has
-// dangerous upstream implications as a result of the usage of this behavior upstream.
-// Remove at your peril.
+// queueRequest enqueues req onto the queue. If the queue is full, it ether
+// returns an error (sync=false) or blocks (sync=true).
+//
+// When sync=true, ctx can be used to break early. When sync=false, ctx will be
+// used later to determine if request should be dropped (if ctx.Err is
+// non-nil).
 //
 // The caller is responsible for checking cli.Error.
-func (cli *socketClient) queueRequest(ctx context.Context, req *types.Request) (*ReqRes, error) {
+func (cli *socketClient) queueRequest(ctx context.Context, req *types.Request, sync bool) (*ReqRes, error) {
 	reqres := NewReqRes(req)

-	select {
-	case cli.reqQueue <- reqres:
-	case <-ctx.Done():
-		return nil, ctx.Err()
+	if sync {
+		select {
+		case cli.reqQueue <- &reqResWithContext{R: reqres, C: context.Background()}:
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		}
+	} else {
+		select {
+		case cli.reqQueue <- &reqResWithContext{R: reqres, C: ctx}:
+		default:
+			return nil, errors.New("buffer is full")
+		}
 	}

 	return reqres, nil
 }

-func (cli *socketClient) queueRequestAndFlush(
+func (cli *socketClient) queueRequestAsync(
 	ctx context.Context,
 	req *types.Request,
 ) (*ReqRes, error) {

-	reqres, err := cli.queueRequest(ctx, req)
+	reqres, err := cli.queueRequest(ctx, req, false)
 	if err != nil {
 		return nil, queueErr(err)
 	}

-	if err := cli.Flush(ctx); err != nil {
+	return reqres, cli.Error()
+}
+
+func (cli *socketClient) queueRequestAndFlushSync(
+	ctx context.Context,
+	req *types.Request,
+) (*ReqRes, error) {
+
+	reqres, err := cli.queueRequest(ctx, req, true)
+	if err != nil {
+		return nil, queueErr(err)
+	}
+
+	if err := cli.FlushSync(ctx); err != nil {
 		return nil, err
 	}

@@ -433,14 +520,14 @@ func queueErr(e error) error {

 // drainQueue marks as complete and discards all remaining pending requests
 // from the queue.
-func (cli *socketClient) drainQueue(ctx context.Context) {
+func (cli *socketClient) drainQueue() {
 	cli.mtx.Lock()
 	defer cli.mtx.Unlock()

 	// mark all in-flight messages as resolved (they will get cli.Error())
 	for req := cli.reqSent.Front(); req != nil; req = req.Next() {
 		reqres := req.Value.(*ReqRes)
-		reqres.SetDone()
+		reqres.Done()
 	}

 	// Mark all queued messages as resolved.
@@ -450,10 +537,8 @@ func (cli *socketClient) drainQueue(ctx context.Context) {
 	// See https://github.com/tendermint/tendermint/issues/6996.
 	for {
 		select {
-		case <-ctx.Done():
-			return
 		case reqres := <-cli.reqQueue:
-			reqres.SetDone()
+			reqres.R.Done()
 		default:
 			return
 		}
@@ -470,6 +555,8 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_Flush)
 	case *types.Request_Info:
 		_, ok = res.Value.(*types.Response_Info)
+	case *types.Request_DeliverTx:
+		_, ok = res.Value.(*types.Response_DeliverTx)
 	case *types.Request_CheckTx:
 		_, ok = res.Value.(*types.Response_CheckTx)
 	case *types.Request_Commit:
@@ -478,12 +565,10 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_Query)
 	case *types.Request_InitChain:
 		_, ok = res.Value.(*types.Response_InitChain)
-	case *types.Request_PrepareProposal:
-		_, ok = res.Value.(*types.Response_PrepareProposal)
-	case *types.Request_ExtendVote:
-		_, ok = res.Value.(*types.Response_ExtendVote)
-	case *types.Request_VerifyVoteExtension:
-		_, ok = res.Value.(*types.Response_VerifyVoteExtension)
+	case *types.Request_BeginBlock:
+		_, ok = res.Value.(*types.Response_BeginBlock)
+	case *types.Request_EndBlock:
+		_, ok = res.Value.(*types.Response_EndBlock)
 	case *types.Request_ApplySnapshotChunk:
 		_, ok = res.Value.(*types.Response_ApplySnapshotChunk)
 	case *types.Request_LoadSnapshotChunk:
@@ -492,8 +577,6 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_ListSnapshots)
 	case *types.Request_OfferSnapshot:
 		_, ok = res.Value.(*types.Response_OfferSnapshot)
-	case *types.Request_FinalizeBlock:
-		_, ok = res.Value.(*types.Response_FinalizeBlock)
 	}
 	return ok
 }
@@ -508,5 +591,7 @@ func (cli *socketClient) stopForError(err error) {
 	cli.mtx.Unlock()

 	cli.logger.Info("Stopping abci.socketClient", "reason", err)
-	cli.Stop()
+	if err := cli.Stop(); err != nil {
+		cli.logger.Error("Error stopping abci.socketClient", "err", err)
+	}
 }
--- a/abci/client/socket_client_test.go
+++ b/abci/client/socket_client_test.go
@@ -23,20 +23,20 @@ func TestProperSyncCalls(t *testing.T) {
 	defer cancel()

 	app := slowApp{}
-	logger := log.NewNopLogger()
+	logger := log.TestingLogger()

 	_, c := setupClientServer(ctx, t, logger, app)

 	resp := make(chan error, 1)
 	go func() {
-		rsp, err := c.FinalizeBlock(ctx, types.RequestFinalizeBlock{})
+		// This is BeginBlockSync unrolled....
+		reqres, err := c.BeginBlockAsync(ctx, types.RequestBeginBlock{})
 		assert.NoError(t, err)
-		assert.NoError(t, c.Flush(ctx))
-		assert.NotNil(t, rsp)
-		select {
-		case <-ctx.Done():
-		case resp <- c.Error():
-		}
+		err = c.FlushSync(ctx)
+		assert.NoError(t, err)
+		res := reqres.Response.GetBeginBlock()
+		assert.NotNil(t, res)
+		resp <- c.Error()
 	}()

 	select {
@@ -79,7 +79,7 @@ type slowApp struct {
 	types.BaseApplication
 }

-func (slowApp) FinalizeBlock(req types.RequestFinalizeBlock) types.ResponseFinalizeBlock {
+func (slowApp) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock {
 	time.Sleep(200 * time.Millisecond)
-	return types.ResponseFinalizeBlock{}
+	return types.ResponseBeginBlock{}
 }
--- a/abci/cmd/abci-cli/abci-cli.go
+++ b/abci/cmd/abci-cli/abci-cli.go
@@ -14,7 +14,6 @@ import (
 	"github.com/spf13/cobra"

 	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/version"

 	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
@@ -22,12 +21,14 @@ import (
 	"github.com/tendermint/tendermint/abci/server"
 	servertest "github.com/tendermint/tendermint/abci/tests/server"
 	"github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/abci/version"
 	"github.com/tendermint/tendermint/proto/tendermint/crypto"
 )

 // client is a global variable so it can be reused by the console
 var (
 	client abciclient.Client
+	logger log.Logger
 )

 // flags
@@ -47,32 +48,34 @@ var (
 	flagPersist string
 )

-func RootCmmand(logger log.Logger) *cobra.Command {
-	return &cobra.Command{
-		Use:   "abci-cli",
-		Short: "the ABCI CLI tool wraps an ABCI client",
-		Long:  "the ABCI CLI tool wraps an ABCI client and is used for testing ABCI servers",
-		PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) {
+var RootCmd = &cobra.Command{
+	Use:   "abci-cli",
+	Short: "the ABCI CLI tool wraps an ABCI client",
+	Long:  "the ABCI CLI tool wraps an ABCI client and is used for testing ABCI servers",
+	PersistentPreRunE: func(cmd *cobra.Command, args []string) error {

-			switch cmd.Use {
-			case "kvstore", "version":
-				return nil
-			}
-
-			if client == nil {
-				var err error
-				client, err = abciclient.NewClient(logger.With("module", "abci-client"), flagAddress, flagAbci, false)
-				if err != nil {
-					return err
-				}
-
-				if err := client.Start(cmd.Context()); err != nil {
-					return err
-				}
-			}
+		switch cmd.Use {
+		case "kvstore", "version":
 			return nil
-		},
-	}
+		}
+
+		if logger == nil {
+			logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
+		}
+
+		if client == nil {
+			var err error
+			client, err = abciclient.NewClient(logger.With("module", "abci-client"), flagAddress, flagAbci, false)
+			if err != nil {
+				return err
+			}
+
+			if err := client.Start(cmd.Context()); err != nil {
+				return err
+			}
+		}
+		return nil
+	},
 }

 // Structure for data passed to print response.
@@ -94,46 +97,56 @@ type queryResponse struct {
 }

 func Execute() error {
-	logger, err := log.NewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo)
-	if err != nil {
-		return err
-	}
-
-	cmd := RootCmmand(logger)
-	addGlobalFlags(cmd)
-	addCommands(cmd, logger)
-	return cmd.Execute()
+	addGlobalFlags()
+	addCommands()
+	return RootCmd.Execute()
 }

-func addGlobalFlags(cmd *cobra.Command) {
-	cmd.PersistentFlags().StringVarP(&flagAddress,
+func addGlobalFlags() {
+	RootCmd.PersistentFlags().StringVarP(&flagAddress,
 		"address",
 		"",
 		"tcp://0.0.0.0:26658",
 		"address of application socket")
-	cmd.PersistentFlags().StringVarP(&flagAbci, "abci", "", "socket", "either socket or grpc")
-	cmd.PersistentFlags().BoolVarP(&flagVerbose,
+	RootCmd.PersistentFlags().StringVarP(&flagAbci, "abci", "", "socket", "either socket or grpc")
+	RootCmd.PersistentFlags().BoolVarP(&flagVerbose,
 		"verbose",
 		"v",
 		false,
 		"print the command and results as if it were a console session")
-	cmd.PersistentFlags().StringVarP(&flagLogLevel, "log_level", "", "debug", "set the logger level")
+	RootCmd.PersistentFlags().StringVarP(&flagLogLevel, "log_level", "", "debug", "set the logger level")
 }

-func addCommands(cmd *cobra.Command, logger log.Logger) {
-	cmd.AddCommand(batchCmd)
-	cmd.AddCommand(consoleCmd)
-	cmd.AddCommand(echoCmd)
-	cmd.AddCommand(infoCmd)
-	cmd.AddCommand(deliverTxCmd)
-	cmd.AddCommand(checkTxCmd)
-	cmd.AddCommand(commitCmd)
-	cmd.AddCommand(versionCmd)
-	cmd.AddCommand(testCmd)
-	cmd.AddCommand(getQueryCmd())
+func addQueryFlags() {
+	queryCmd.PersistentFlags().StringVarP(&flagPath, "path", "", "/store", "path to prefix query with")
+	queryCmd.PersistentFlags().IntVarP(&flagHeight, "height", "", 0, "height to query the blockchain at")
+	queryCmd.PersistentFlags().BoolVarP(&flagProve,
+		"prove",
+		"",
+		false,
+		"whether or not to return a merkle proof of the query result")
+}
+
+func addKVStoreFlags() {
+	kvstoreCmd.PersistentFlags().StringVarP(&flagPersist, "persist", "", "", "directory to use for a database")
+}
+
+func addCommands() {
+	RootCmd.AddCommand(batchCmd)
+	RootCmd.AddCommand(consoleCmd)
+	RootCmd.AddCommand(echoCmd)
+	RootCmd.AddCommand(infoCmd)
+	RootCmd.AddCommand(deliverTxCmd)
+	RootCmd.AddCommand(checkTxCmd)
+	RootCmd.AddCommand(commitCmd)
+	RootCmd.AddCommand(versionCmd)
+	RootCmd.AddCommand(testCmd)
+	addQueryFlags()
+	RootCmd.AddCommand(queryCmd)

 	// examples
-	cmd.AddCommand(getKVStoreCmd(logger))
+	addKVStoreFlags()
+	RootCmd.AddCommand(kvstoreCmd)
 }

 var batchCmd = &cobra.Command{
@@ -193,7 +206,7 @@ var deliverTxCmd = &cobra.Command{
 	Short: "deliver a new transaction to the application",
 	Long:  "deliver a new transaction to the application",
 	Args:  cobra.ExactArgs(1),
-	RunE:  cmdFinalizeBlock,
+	RunE:  cmdDeliverTx,
 }

 var checkTxCmd = &cobra.Command{
@@ -218,43 +231,25 @@ var versionCmd = &cobra.Command{
 	Long:  "print ABCI console version",
 	Args:  cobra.ExactArgs(0),
 	RunE: func(cmd *cobra.Command, args []string) error {
-		fmt.Println(version.ABCIVersion)
+		fmt.Println(version.Version)
 		return nil
 	},
 }

-func getQueryCmd() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "query",
-		Short: "query the application state",
-		Long:  "query the application state",
-		Args:  cobra.ExactArgs(1),
-		RunE:  cmdQuery,
-	}
-
-	cmd.PersistentFlags().StringVarP(&flagPath, "path", "", "/store", "path to prefix query with")
-	cmd.PersistentFlags().IntVarP(&flagHeight, "height", "", 0, "height to query the blockchain at")
-	cmd.PersistentFlags().BoolVarP(&flagProve,
-		"prove",
-		"",
-		false,
-		"whether or not to return a merkle proof of the query result")
-
-	return cmd
+var queryCmd = &cobra.Command{
+	Use:   "query",
+	Short: "query the application state",
+	Long:  "query the application state",
+	Args:  cobra.ExactArgs(1),
+	RunE:  cmdQuery,
 }

-func getKVStoreCmd(logger log.Logger) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "kvstore",
-		Short: "ABCI demo example",
-		Long:  "ABCI demo example",
-		Args:  cobra.ExactArgs(0),
-		RunE:  makeKVStoreCmd(logger),
-	}
-
-	cmd.PersistentFlags().StringVarP(&flagPersist, "persist", "", "", "directory to use for a database")
-	return cmd
-
+var kvstoreCmd = &cobra.Command{
+	Use:   "kvstore",
+	Short: "ABCI demo example",
+	Long:  "ABCI demo example",
+	Args:  cobra.ExactArgs(0),
+	RunE:  cmdKVStore,
 }

 var testCmd = &cobra.Command{
@@ -300,38 +295,17 @@ func cmdTest(cmd *cobra.Command, args []string) error {
 		[]func() error{
 			func() error { return servertest.InitChain(ctx, client) },
 			func() error { return servertest.Commit(ctx, client, nil) },
-			func() error {
-				return servertest.FinalizeBlock(ctx, client, [][]byte{
-					[]byte("abc"),
-				}, []uint32{
-					code.CodeTypeBadNonce,
-				}, nil)
-			},
+			func() error { return servertest.DeliverTx(ctx, client, []byte("abc"), code.CodeTypeBadNonce, nil) },
 			func() error { return servertest.Commit(ctx, client, nil) },
-			func() error {
-				return servertest.FinalizeBlock(ctx, client, [][]byte{
-					{0x00},
-				}, []uint32{
-					code.CodeTypeOK,
-				}, nil)
-			},
+			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00}, code.CodeTypeOK, nil) },
 			func() error { return servertest.Commit(ctx, client, []byte{0, 0, 0, 0, 0, 0, 0, 1}) },
+			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00}, code.CodeTypeBadNonce, nil) },
+			func() error { return servertest.DeliverTx(ctx, client, []byte{0x01}, code.CodeTypeOK, nil) },
+			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00, 0x02}, code.CodeTypeOK, nil) },
+			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00, 0x03}, code.CodeTypeOK, nil) },
+			func() error { return servertest.DeliverTx(ctx, client, []byte{0x00, 0x00, 0x04}, code.CodeTypeOK, nil) },
 			func() error {
-				return servertest.FinalizeBlock(ctx, client, [][]byte{
-					{0x00},
-					{0x01},
-					{0x00, 0x02},
-					{0x00, 0x03},
-					{0x00, 0x00, 0x04},
-					{0x00, 0x00, 0x06},
-				}, []uint32{
-					code.CodeTypeBadNonce,
-					code.CodeTypeOK,
-					code.CodeTypeOK,
-					code.CodeTypeOK,
-					code.CodeTypeOK,
-					code.CodeTypeBadNonce,
-				}, nil)
+				return servertest.DeliverTx(ctx, client, []byte{0x00, 0x00, 0x06}, code.CodeTypeBadNonce, nil)
 			},
 			func() error { return servertest.Commit(ctx, client, []byte{0, 0, 0, 0, 0, 0, 0, 5}) },
 		})
@@ -427,7 +401,7 @@ func muxOnCommands(cmd *cobra.Command, pArgs []string) error {
 	case "commit":
 		return cmdCommit(cmd, actualArgs)
 	case "deliver_tx":
-		return cmdFinalizeBlock(cmd, actualArgs)
+		return cmdDeliverTx(cmd, actualArgs)
 	case "echo":
 		return cmdEcho(cmd, actualArgs)
 	case "info":
@@ -451,9 +425,12 @@ func cmdUnimplemented(cmd *cobra.Command, args []string) error {
 	})

 	fmt.Println("Available commands:")
-	for _, cmd := range cmd.Commands() {
-		fmt.Printf("%s: %s\n", cmd.Use, cmd.Short)
-	}
+	fmt.Printf("%s: %s\n", echoCmd.Use, echoCmd.Short)
+	fmt.Printf("%s: %s\n", infoCmd.Use, infoCmd.Short)
+	fmt.Printf("%s: %s\n", checkTxCmd.Use, checkTxCmd.Short)
+	fmt.Printf("%s: %s\n", deliverTxCmd.Use, deliverTxCmd.Short)
+	fmt.Printf("%s: %s\n", queryCmd.Use, queryCmd.Short)
+	fmt.Printf("%s: %s\n", commitCmd.Use, commitCmd.Short)
 	fmt.Println("Use \"[command] --help\" for more information about a command.")

 	return nil
@@ -465,7 +442,7 @@ func cmdEcho(cmd *cobra.Command, args []string) error {
 	if len(args) > 0 {
 		msg = args[0]
 	}
-	res, err := client.Echo(cmd.Context(), msg)
+	res, err := client.EchoSync(cmd.Context(), msg)
 	if err != nil {
 		return err
 	}
@@ -483,7 +460,7 @@ func cmdInfo(cmd *cobra.Command, args []string) error {
 	if len(args) == 1 {
 		version = args[0]
 	}
-	res, err := client.Info(cmd.Context(), types.RequestInfo{Version: version})
+	res, err := client.InfoSync(cmd.Context(), types.RequestInfo{Version: version})
 	if err != nil {
 		return err
 	}
@@ -496,7 +473,7 @@ func cmdInfo(cmd *cobra.Command, args []string) error {
 const codeBad uint32 = 10

 // Append a new tx to application
-func cmdFinalizeBlock(cmd *cobra.Command, args []string) error {
+func cmdDeliverTx(cmd *cobra.Command, args []string) error {
 	if len(args) == 0 {
 		printResponse(cmd, args, response{
 			Code: codeBad,
@@ -508,18 +485,16 @@ func cmdFinalizeBlock(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	res, err := client.FinalizeBlock(cmd.Context(), types.RequestFinalizeBlock{Txs: [][]byte{txBytes}})
+	res, err := client.DeliverTxSync(cmd.Context(), types.RequestDeliverTx{Tx: txBytes})
 	if err != nil {
 		return err
 	}
-	for _, tx := range res.Txs {
-		printResponse(cmd, args, response{
-			Code: tx.Code,
-			Data: tx.Data,
-			Info: tx.Info,
-			Log:  tx.Log,
-		})
-	}
+	printResponse(cmd, args, response{
+		Code: res.Code,
+		Data: res.Data,
+		Info: res.Info,
+		Log:  res.Log,
+	})
 	return nil
 }

@@ -536,7 +511,7 @@ func cmdCheckTx(cmd *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	res, err := client.CheckTx(cmd.Context(), types.RequestCheckTx{Tx: txBytes})
+	res, err := client.CheckTxSync(cmd.Context(), types.RequestCheckTx{Tx: txBytes})
 	if err != nil {
 		return err
 	}
@@ -551,7 +526,7 @@ func cmdCheckTx(cmd *cobra.Command, args []string) error {

 // Get application Merkle root hash
 func cmdCommit(cmd *cobra.Command, args []string) error {
-	res, err := client.Commit(cmd.Context())
+	res, err := client.CommitSync(cmd.Context())
 	if err != nil {
 		return err
 	}
@@ -576,7 +551,7 @@ func cmdQuery(cmd *cobra.Command, args []string) error {
 		return err
 	}

-	resQuery, err := client.Query(cmd.Context(), types.RequestQuery{
+	resQuery, err := client.QuerySync(cmd.Context(), types.RequestQuery{
 		Data:   queryBytes,
 		Path:   flagPath,
 		Height: int64(flagHeight),
@@ -599,34 +574,34 @@ func cmdQuery(cmd *cobra.Command, args []string) error {
 	return nil
 }

-func makeKVStoreCmd(logger log.Logger) func(*cobra.Command, []string) error {
-	return func(cmd *cobra.Command, args []string) error {
-		// Create the application - in memory or persisted to disk
-		var app types.Application
-		if flagPersist == "" {
-			app = kvstore.NewApplication()
-		} else {
-			app = kvstore.NewPersistentKVStoreApplication(logger, flagPersist)
-		}
+func cmdKVStore(cmd *cobra.Command, args []string) error {
+	logger := log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)

-		// Start the listener
-		srv, err := server.NewServer(logger.With("module", "abci-server"), flagAddress, flagAbci, app)
-		if err != nil {
-			return err
-		}
-
-		ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM)
-		defer cancel()
-
-		if err := srv.Start(ctx); err != nil {
-			return err
-		}
-
-		// Run forever.
-		<-ctx.Done()
-		return nil
+	// Create the application - in memory or persisted to disk
+	var app types.Application
+	if flagPersist == "" {
+		app = kvstore.NewApplication()
+	} else {
+		app = kvstore.NewPersistentKVStoreApplication(flagPersist)
+		app.(*kvstore.PersistentKVStoreApplication).SetLogger(logger.With("module", "kvstore"))
 	}

+	// Start the listener
+	srv, err := server.NewServer(logger.With("module", "abci-server"), flagAddress, flagAbci, app)
+	if err != nil {
+		return err
+	}
+
+	ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM)
+	defer cancel()
+
+	if err := srv.Start(ctx); err != nil {
+		return err
+	}
+
+	// Run forever.
+	<-ctx.Done()
+	return nil
 }

 //--------------------------------------------------------------------------------
--- a/abci/example/example_test.go
+++ b/abci/example/example_test.go
@@ -6,13 +6,13 @@ import (
 	"math/rand"
 	"net"
 	"os"
+	"reflect"
 	"testing"
 	"time"

 	"github.com/stretchr/testify/require"

 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials/insecure"

 	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
@@ -31,38 +31,34 @@ func init() {
 func TestKVStore(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	logger := log.NewTestingLogger(t)

-	logger.Info("### Testing KVStore")
-	testBulk(ctx, t, logger, kvstore.NewApplication())
+	fmt.Println("### Testing KVStore")
+	testStream(ctx, t, kvstore.NewApplication())
 }

 func TestBaseApp(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	logger := log.NewTestingLogger(t)
-
-	logger.Info("### Testing BaseApp")
-	testBulk(ctx, t, logger, types.NewBaseApplication())
+	fmt.Println("### Testing BaseApp")
+	testStream(ctx, t, types.NewBaseApplication())
 }

 func TestGRPC(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()

-	logger := log.NewTestingLogger(t)
-
-	logger.Info("### Testing GRPC")
-	testGRPCSync(ctx, t, logger, types.NewGRPCApplication(types.NewBaseApplication()))
+	fmt.Println("### Testing GRPC")
+	testGRPCSync(ctx, t, types.NewGRPCApplication(types.NewBaseApplication()))
 }

-func testBulk(ctx context.Context, t *testing.T, logger log.Logger, app types.Application) {
+func testStream(ctx context.Context, t *testing.T, app types.Application) {
 	t.Helper()

-	const numDeliverTxs = 700000
+	const numDeliverTxs = 20000
 	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
 	defer os.Remove(socketFile)
 	socket := fmt.Sprintf("unix://%v", socketFile)
+	logger := log.TestingLogger()
 	// Start the listener
 	server := abciserver.NewSocketServer(logger.With("module", "abci-server"), socket, app)
 	t.Cleanup(server.Wait)
@@ -70,28 +66,57 @@ func testBulk(ctx context.Context, t *testing.T, logger log.Logger, app types.Ap
 	require.NoError(t, err)

 	// Connect to the socket
-	client := abciclient.NewSocketClient(logger.With("module", "abci-client"), socket, false)
+	client := abciclient.NewSocketClient(log.TestingLogger().With("module", "abci-client"), socket, false)
 	t.Cleanup(client.Wait)

 	err = client.Start(ctx)
 	require.NoError(t, err)

-	// Construct request
-	rfb := types.RequestFinalizeBlock{Txs: make([][]byte, numDeliverTxs)}
+	done := make(chan struct{})
+	counter := 0
+	client.SetResponseCallback(func(req *types.Request, res *types.Response) {
+		// Process response
+		switch r := res.Value.(type) {
+		case *types.Response_DeliverTx:
+			counter++
+			if r.DeliverTx.Code != code.CodeTypeOK {
+				t.Error("DeliverTx failed with ret_code", r.DeliverTx.Code)
+			}
+			if counter > numDeliverTxs {
+				t.Fatalf("Too many DeliverTx responses. Got %d, expected %d", counter, numDeliverTxs)
+			}
+			if counter == numDeliverTxs {
+				go func() {
+					time.Sleep(time.Second * 1) // Wait for a bit to allow counter overflow
+					close(done)
+				}()
+				return
+			}
+		case *types.Response_Flush:
+			// ignore
+		default:
+			t.Error("Unexpected response type", reflect.TypeOf(res.Value))
+		}
+	})
+
+	// Write requests
 	for counter := 0; counter < numDeliverTxs; counter++ {
-		rfb.Txs[counter] = []byte("test")
-	}
-	// Send bulk request
-	res, err := client.FinalizeBlock(ctx, rfb)
-	require.NoError(t, err)
-	require.Equal(t, numDeliverTxs, len(res.Txs), "Number of txs doesn't match")
-	for _, tx := range res.Txs {
-		require.Equal(t, tx.Code, code.CodeTypeOK, "Tx failed")
+		// Send request
+		_, err = client.DeliverTxAsync(ctx, types.RequestDeliverTx{Tx: []byte("test")})
+		require.NoError(t, err)
+
+		// Sometimes send flush messages
+		if counter%128 == 0 {
+			err = client.FlushSync(context.Background())
+			require.NoError(t, err)
+		}
 	}

 	// Send final flush message
-	err = client.Flush(ctx)
+	_, err = client.FlushAsync(ctx)
 	require.NoError(t, err)
+
+	<-done
 }

 //-------------------------
@@ -101,25 +126,26 @@ func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
 	return tmnet.Connect(addr)
 }

-func testGRPCSync(ctx context.Context, t *testing.T, logger log.Logger, app types.ABCIApplicationServer) {
-	t.Helper()
-	numDeliverTxs := 680000
+func testGRPCSync(ctx context.Context, t *testing.T, app types.ABCIApplicationServer) {
+	numDeliverTxs := 2000
 	socketFile := fmt.Sprintf("/tmp/test-%08x.sock", rand.Int31n(1<<30))
 	defer os.Remove(socketFile)
 	socket := fmt.Sprintf("unix://%v", socketFile)
-
+	logger := log.TestingLogger()
 	// Start the listener
 	server := abciserver.NewGRPCServer(logger.With("module", "abci-server"), socket, app)

-	require.NoError(t, server.Start(ctx))
-	t.Cleanup(server.Wait)
+	if err := server.Start(ctx); err != nil {
+		t.Fatalf("Error starting GRPC server: %v", err.Error())
+	}
+
+	t.Cleanup(func() { server.Wait() })

 	// Connect to the socket
-	conn, err := grpc.Dial(socket,
-		grpc.WithTransportCredentials(insecure.NewCredentials()),
-		grpc.WithContextDialer(dialerFunc),
-	)
-	require.NoError(t, err, "Error dialing GRPC server")
+	conn, err := grpc.Dial(socket, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
+	if err != nil {
+		t.Fatalf("Error dialing GRPC server: %v", err.Error())
+	}

 	t.Cleanup(func() {
 		if err := conn.Close(); err != nil {
@@ -129,17 +155,26 @@ func testGRPCSync(ctx context.Context, t *testing.T, logger log.Logger, app type

 	client := types.NewABCIApplicationClient(conn)

-	// Construct request
-	rfb := types.RequestFinalizeBlock{Txs: make([][]byte, numDeliverTxs)}
+	// Write requests
 	for counter := 0; counter < numDeliverTxs; counter++ {
-		rfb.Txs[counter] = []byte("test")
-	}
+		// Send request
+		response, err := client.DeliverTx(context.Background(), &types.RequestDeliverTx{Tx: []byte("test")})
+		if err != nil {
+			t.Fatalf("Error in GRPC DeliverTx: %v", err.Error())
+		}
+		counter++
+		if response.Code != code.CodeTypeOK {
+			t.Error("DeliverTx failed with ret_code", response.Code)
+		}
+		if counter > numDeliverTxs {
+			t.Fatal("Too many DeliverTx responses")
+		}
+		t.Log("response", counter)
+		if counter == numDeliverTxs {
+			go func() {
+				time.Sleep(time.Second * 1) // Wait for a bit to allow counter overflow
+			}()
+		}

-	// Send request
-	response, err := client.FinalizeBlock(ctx, &rfb)
-	require.NoError(t, err, "Error in GRPC FinalizeBlock")
-	require.Equal(t, numDeliverTxs, len(response.Txs), "Number of txs returned via GRPC doesn't match")
-	for _, tx := range response.Txs {
-		require.Equal(t, tx.Code, code.CodeTypeOK, "Tx failed")
 	}
 }
--- a/abci/example/kvstore/README.md
+++ b/abci/example/kvstore/README.md
@@ -4,7 +4,7 @@ There are two app's here: the KVStoreApplication and the PersistentKVStoreApplic

 ## KVStoreApplication

-The KVStoreApplication is a simple merkle key-value store.
+The KVStoreApplication is a simple merkle key-value store. 
 Transactions of the form `key=value` are stored as key-value pairs in the tree.
 Transactions without an `=` sign set the value to the key.
 The app has no replay protection (other than what the mempool provides).
@@ -12,7 +12,7 @@ The app has no replay protection (other than what the mempool provides).
 ## PersistentKVStoreApplication

 The PersistentKVStoreApplication wraps the KVStoreApplication
-and provides three additional features:
+and provides two additional features:

 1) persistence of state across app restarts (using Tendermint's ABCI-Handshake mechanism)
 2) validator set changes
@@ -27,4 +27,4 @@ Validator set changes are effected using the following transaction format:

 where `pubkeyN` is a base64-encoded 32-byte ed25519 key and `powerN` is a new voting power for the validator with `pubkeyN` (possibly a new one).
 To remove a validator from the validator set, set power to `0`.
-There is no sybil protection against new validators joining.
+There is no sybil protection against new validators joining. 
--- a/abci/example/kvstore/kvstore.go
+++ b/abci/example/kvstore/kvstore.go
@@ -86,13 +86,14 @@ func (app *Application) Info(req types.RequestInfo) (resInfo types.ResponseInfo)
 }

 // tx is either "key=value" or just arbitrary bytes
-func (app *Application) HandleTx(tx []byte) *types.ResponseDeliverTx {
+func (app *Application) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverTx {
 	var key, value string
-	parts := bytes.Split(tx, []byte("="))
+
+	parts := bytes.Split(req.Tx, []byte("="))
 	if len(parts) == 2 {
 		key, value = string(parts[0]), string(parts[1])
 	} else {
-		key, value = string(tx), string(tx)
+		key, value = string(req.Tx), string(req.Tx)
 	}

 	err := app.state.db.Set(prefixKey([]byte(key)), []byte(value))
@@ -113,15 +114,7 @@ func (app *Application) HandleTx(tx []byte) *types.ResponseDeliverTx {
 		},
 	}

-	return &types.ResponseDeliverTx{Code: code.CodeTypeOK, Events: events}
-}
-
-func (app *Application) FinalizeBlock(req types.RequestFinalizeBlock) types.ResponseFinalizeBlock {
-	txs := make([]*types.ResponseDeliverTx, len(req.Txs))
-	for i, tx := range req.Txs {
-		txs[i] = app.HandleTx(tx)
-	}
-	return types.ResponseFinalizeBlock{Txs: txs}
+	return types.ResponseDeliverTx{Code: code.CodeTypeOK, Events: events}
 }

 func (app *Application) CheckTx(req types.RequestCheckTx) types.ResponseCheckTx {
@@ -178,9 +171,3 @@ 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}
-}
--- a/abci/example/kvstore/kvstore_test.go
+++ b/abci/example/kvstore/kvstore_test.go
@@ -3,6 +3,7 @@ package kvstore
 import (
 	"context"
 	"fmt"
+	"os"
 	"sort"
 	"testing"

@@ -24,14 +25,12 @@ const (
 )

 func testKVStore(t *testing.T, app types.Application, tx []byte, key, value string) {
-	req := types.RequestFinalizeBlock{Txs: [][]byte{tx}}
-	ar := app.FinalizeBlock(req)
-	require.Equal(t, 1, len(ar.Txs))
-	require.False(t, ar.Txs[0].IsErr())
+	req := types.RequestDeliverTx{Tx: tx}
+	ar := app.DeliverTx(req)
+	require.False(t, ar.IsErr(), ar)
 	// repeating tx doesn't raise error
-	ar = app.FinalizeBlock(req)
-	require.Equal(t, 1, len(ar.Txs))
-	require.False(t, ar.Txs[0].IsErr())
+	ar = app.DeliverTx(req)
+	require.False(t, ar.IsErr(), ar)
 	// commit
 	app.Commit()

@@ -73,10 +72,11 @@ func TestKVStoreKV(t *testing.T) {
 }

 func TestPersistentKVStoreKV(t *testing.T) {
-	dir := t.TempDir()
-	logger := log.NewTestingLogger(t)
-
-	kvstore := NewPersistentKVStoreApplication(logger, dir)
+	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
+	if err != nil {
+		t.Fatal(err)
+	}
+	kvstore := NewPersistentKVStoreApplication(dir)
 	key := testKey
 	value := key
 	tx := []byte(key)
@@ -88,10 +88,11 @@ func TestPersistentKVStoreKV(t *testing.T) {
 }

 func TestPersistentKVStoreInfo(t *testing.T) {
-	dir := t.TempDir()
-	logger := log.NewTestingLogger(t)
-
-	kvstore := NewPersistentKVStoreApplication(logger, dir)
+	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
+	if err != nil {
+		t.Fatal(err)
+	}
+	kvstore := NewPersistentKVStoreApplication(dir)
 	InitKVStore(kvstore)
 	height := int64(0)

@@ -106,7 +107,8 @@ func TestPersistentKVStoreInfo(t *testing.T) {
 	header := tmproto.Header{
 		Height: height,
 	}
-	kvstore.FinalizeBlock(types.RequestFinalizeBlock{Hash: hash, Header: header, Height: height})
+	kvstore.BeginBlock(types.RequestBeginBlock{Hash: hash, Header: header})
+	kvstore.EndBlock(types.RequestEndBlock{Height: header.Height})
 	kvstore.Commit()

 	resInfo = kvstore.Info(types.RequestInfo{})
@@ -118,10 +120,11 @@ func TestPersistentKVStoreInfo(t *testing.T) {

 // add a validator, remove a validator, update a validator
 func TestValUpdates(t *testing.T) {
-	dir := t.TempDir()
-	logger := log.NewTestingLogger(t)
-
-	kvstore := NewPersistentKVStoreApplication(logger, dir)
+	dir, err := os.MkdirTemp("/tmp", "abci-kvstore-test") // TODO
+	if err != nil {
+		t.Fatal(err)
+	}
+	kvstore := NewPersistentKVStoreApplication(dir)

 	// init with some validators
 	total := 10
@@ -195,16 +198,16 @@ func makeApplyBlock(
 		Height: height,
 	}

-	resFinalizeBlock := kvstore.FinalizeBlock(types.RequestFinalizeBlock{
-		Hash:   hash,
-		Header: header,
-		Height: height,
-		Txs:    txs,
-	})
-
+	kvstore.BeginBlock(types.RequestBeginBlock{Hash: hash, Header: header})
+	for _, tx := range txs {
+		if r := kvstore.DeliverTx(types.RequestDeliverTx{Tx: tx}); r.IsErr() {
+			t.Fatal(r)
+		}
+	}
+	resEndBlock := kvstore.EndBlock(types.RequestEndBlock{Height: header.Height})
 	kvstore.Commit()

-	valsEqual(t, diff, resFinalizeBlock.ValidatorUpdates)
+	valsEqual(t, diff, resEndBlock.ValidatorUpdates)

 }

@@ -286,7 +289,7 @@ func makeGRPCClientServer(
 func TestClientServer(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	logger := log.NewTestingLogger(t)
+	logger := log.TestingLogger()

 	// set up socket app
 	kvstore := NewApplication()
@@ -321,41 +324,39 @@ func runClientTests(ctx context.Context, t *testing.T, client abciclient.Client)
 }

 func testClient(ctx context.Context, t *testing.T, app abciclient.Client, tx []byte, key, value string) {
-	ar, err := app.FinalizeBlock(ctx, types.RequestFinalizeBlock{Txs: [][]byte{tx}})
+	ar, err := app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
 	require.NoError(t, err)
-	require.Equal(t, 1, len(ar.Txs))
-	require.False(t, ar.Txs[0].IsErr())
-	// repeating FinalizeBlock doesn't raise error
-	ar, err = app.FinalizeBlock(ctx, types.RequestFinalizeBlock{Txs: [][]byte{tx}})
+	require.False(t, ar.IsErr(), ar)
+	// repeating tx doesn't raise error
+	ar, err = app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
 	require.NoError(t, err)
-	require.Equal(t, 1, len(ar.Txs))
-	require.False(t, ar.Txs[0].IsErr())
+	require.False(t, ar.IsErr(), ar)
 	// commit
-	_, err = app.Commit(ctx)
+	_, err = app.CommitSync(ctx)
 	require.NoError(t, err)

-	info, err := app.Info(ctx, types.RequestInfo{})
+	info, err := app.InfoSync(ctx, types.RequestInfo{})
 	require.NoError(t, err)
 	require.NotZero(t, info.LastBlockHeight)

 	// make sure query is fine
-	resQuery, err := app.Query(ctx, types.RequestQuery{
+	resQuery, err := app.QuerySync(ctx, types.RequestQuery{
 		Path: "/store",
 		Data: []byte(key),
 	})
-	require.NoError(t, err)
+	require.Nil(t, err)
 	require.Equal(t, code.CodeTypeOK, resQuery.Code)
 	require.Equal(t, key, string(resQuery.Key))
 	require.Equal(t, value, string(resQuery.Value))
 	require.EqualValues(t, info.LastBlockHeight, resQuery.Height)

 	// make sure proof is fine
-	resQuery, err = app.Query(ctx, types.RequestQuery{
+	resQuery, err = app.QuerySync(ctx, types.RequestQuery{
 		Path:  "/store",
 		Data:  []byte(key),
 		Prove: true,
 	})
-	require.NoError(t, err)
+	require.Nil(t, err)
 	require.Equal(t, code.CodeTypeOK, resQuery.Code)
 	require.Equal(t, key, string(resQuery.Key))
 	require.Equal(t, value, string(resQuery.Value))
--- a/abci/example/kvstore/persistent_kvstore.go
+++ b/abci/example/kvstore/persistent_kvstore.go
@@ -14,7 +14,6 @@ import (
 	"github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/libs/log"
 	cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto"
-	ptypes "github.com/tendermint/tendermint/proto/tendermint/types"
 )

 const (
@@ -36,7 +35,7 @@ type PersistentKVStoreApplication struct {
 	logger log.Logger
 }

-func NewPersistentKVStoreApplication(logger log.Logger, dbDir string) *PersistentKVStoreApplication {
+func NewPersistentKVStoreApplication(dbDir string) *PersistentKVStoreApplication {
 	name := "kvstore"
 	db, err := dbm.NewGoLevelDB(name, dbDir)
 	if err != nil {
@@ -48,7 +47,7 @@ func NewPersistentKVStoreApplication(logger log.Logger, dbDir string) *Persisten
 	return &PersistentKVStoreApplication{
 		app:                &Application{state: state},
 		valAddrToPubKeyMap: make(map[string]cryptoproto.PublicKey),
-		logger:             logger,
+		logger:             log.NewNopLogger(),
 	}
 }

@@ -56,6 +55,10 @@ func (app *PersistentKVStoreApplication) Close() error {
 	return app.app.state.db.Close()
 }

+func (app *PersistentKVStoreApplication) SetLogger(l log.Logger) {
+	app.logger = l
+}
+
 func (app *PersistentKVStoreApplication) Info(req types.RequestInfo) types.ResponseInfo {
 	res := app.app.Info(req)
 	res.LastBlockHeight = app.app.state.Height
@@ -64,21 +67,17 @@ func (app *PersistentKVStoreApplication) Info(req types.RequestInfo) types.Respo
 }

 // tx is either "val:pubkey!power" or "key=value" or just arbitrary bytes
-func (app *PersistentKVStoreApplication) HandleTx(tx []byte) *types.ResponseDeliverTx {
+func (app *PersistentKVStoreApplication) DeliverTx(req types.RequestDeliverTx) types.ResponseDeliverTx {
 	// if it starts with "val:", update the validator set
 	// format is "val:pubkey!power"
-	if isValidatorTx(tx) {
+	if isValidatorTx(req.Tx) {
 		// update validators in the merkle tree
 		// and in app.ValUpdates
-		return app.execValidatorTx(tx)
-	}
-
-	if isPrepareTx(tx) {
-		return app.execPrepareTx(tx)
+		return app.execValidatorTx(req.Tx)
 	}

 	// otherwise, update the key-value store
-	return app.app.HandleTx(tx)
+	return app.app.DeliverTx(req)
 }

 func (app *PersistentKVStoreApplication) CheckTx(req types.RequestCheckTx) types.ResponseCheckTx {
@@ -114,16 +113,14 @@ func (app *PersistentKVStoreApplication) InitChain(req types.RequestInitChain) t
 	for _, v := range req.Validators {
 		r := app.updateValidator(v)
 		if r.IsErr() {
-			app.logger.Error("error updating validators", "r", r)
+			app.logger.Error("Error updating validators", "r", r)
 		}
 	}
 	return types.ResponseInitChain{}
 }

 // Track the block hash and header information
-// Execute transactions
-// Update the validator set
-func (app *PersistentKVStoreApplication) FinalizeBlock(req types.RequestFinalizeBlock) types.ResponseFinalizeBlock {
+func (app *PersistentKVStoreApplication) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock {
 	// reset valset changes
 	app.ValUpdates = make([]types.ValidatorUpdate, 0)

@@ -145,12 +142,12 @@ func (app *PersistentKVStoreApplication) FinalizeBlock(req types.RequestFinalize
 		}
 	}

-	respTxs := make([]*types.ResponseDeliverTx, len(req.Txs))
-	for i, tx := range req.Txs {
-		respTxs[i] = app.HandleTx(tx)
-	}
+	return types.ResponseBeginBlock{}
+}

-	return types.ResponseFinalizeBlock{Txs: respTxs, ValidatorUpdates: app.ValUpdates}
+// Update the validator set
+func (app *PersistentKVStoreApplication) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock {
+	return types.ResponseEndBlock{ValidatorUpdates: app.ValUpdates}
 }

 func (app *PersistentKVStoreApplication) ListSnapshots(
@@ -173,34 +170,6 @@ func (app *PersistentKVStoreApplication) ApplySnapshotChunk(
 	return types.ResponseApplySnapshotChunk{Result: types.ResponseApplySnapshotChunk_ABORT}
 }

-func (app *PersistentKVStoreApplication) ExtendVote(
-	req types.RequestExtendVote) types.ResponseExtendVote {
-	return types.ResponseExtendVote{
-		VoteExtension: ConstructVoteExtension(req.Vote.ValidatorAddress),
-	}
-}
-
-func (app *PersistentKVStoreApplication) VerifyVoteExtension(
-	req types.RequestVerifyVoteExtension) types.ResponseVerifyVoteExtension {
-	return types.RespondVerifyVoteExtension(
-		app.verifyExtension(req.Vote.ValidatorAddress, req.Vote.VoteExtension))
-}
-
-func (app *PersistentKVStoreApplication) PrepareProposal(
-	req types.RequestPrepareProposal) types.ResponsePrepareProposal {
-	return types.ResponsePrepareProposal{BlockData: app.substPrepareTx(req.BlockData)}
-}
-
-func (app *PersistentKVStoreApplication) ProcessProposal(
-	req types.RequestProcessProposal) types.ResponseProcessProposal {
-	for _, tx := range req.Txs {
-		if len(tx) == 0 {
-			return types.ResponseProcessProposal{Result: types.ResponseProcessProposal_REJECT}
-		}
-	}
-	return types.ResponseProcessProposal{Result: types.ResponseProcessProposal_ACCEPT}
-}
-
 //---------------------------------------------
 // update validators

@@ -240,13 +209,13 @@ func isValidatorTx(tx []byte) bool {

 // format is "val:pubkey!power"
 // pubkey is a base64-encoded 32-byte ed25519 key
-func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) *types.ResponseDeliverTx {
+func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.ResponseDeliverTx {
 	tx = tx[len(ValidatorSetChangePrefix):]

 	//  get the pubkey and power
 	pubKeyAndPower := strings.Split(string(tx), "!")
 	if len(pubKeyAndPower) != 2 {
-		return &types.ResponseDeliverTx{
+		return types.ResponseDeliverTx{
 			Code: code.CodeTypeEncodingError,
 			Log:  fmt.Sprintf("Expected 'pubkey!power'. Got %v", pubKeyAndPower)}
 	}
@@ -255,7 +224,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) *types.Respo
 	// decode the pubkey
 	pubkey, err := base64.StdEncoding.DecodeString(pubkeyS)
 	if err != nil {
-		return &types.ResponseDeliverTx{
+		return types.ResponseDeliverTx{
 			Code: code.CodeTypeEncodingError,
 			Log:  fmt.Sprintf("Pubkey (%s) is invalid base64", pubkeyS)}
 	}
@@ -263,7 +232,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) *types.Respo
 	// decode the power
 	power, err := strconv.ParseInt(powerS, 10, 64)
 	if err != nil {
-		return &types.ResponseDeliverTx{
+		return types.ResponseDeliverTx{
 			Code: code.CodeTypeEncodingError,
 			Log:  fmt.Sprintf("Power (%s) is not an int", powerS)}
 	}
@@ -273,7 +242,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) *types.Respo
 }

 // add, update, or remove a validator
-func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate) *types.ResponseDeliverTx {
+func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate) types.ResponseDeliverTx {
 	pubkey, err := encoding.PubKeyFromProto(v.PubKey)
 	if err != nil {
 		panic(fmt.Errorf("can't decode public key: %w", err))
@@ -288,7 +257,7 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate
 		}
 		if !hasKey {
 			pubStr := base64.StdEncoding.EncodeToString(pubkey.Bytes())
-			return &types.ResponseDeliverTx{
+			return types.ResponseDeliverTx{
 				Code: code.CodeTypeUnauthorized,
 				Log:  fmt.Sprintf("Cannot remove non-existent validator %s", pubStr)}
 		}
@@ -300,9 +269,9 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate
 		// add or update validator
 		value := bytes.NewBuffer(make([]byte, 0))
 		if err := types.WriteMessage(&v, value); err != nil {
-			return &types.ResponseDeliverTx{
+			return types.ResponseDeliverTx{
 				Code: code.CodeTypeEncodingError,
-				Log:  fmt.Sprintf("error encoding validator: %v", err)}
+				Log:  fmt.Sprintf("Error encoding validator: %v", err)}
 		}
 		if err = app.app.state.db.Set(key, value.Bytes()); err != nil {
 			panic(err)
@@ -313,55 +282,5 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate
 	// we only update the changes array if we successfully updated the tree
 	app.ValUpdates = append(app.ValUpdates, v)

-	return &types.ResponseDeliverTx{Code: code.CodeTypeOK}
-}
-
-// -----------------------------
-
-const PreparePrefix = "prepare"
-
-func isPrepareTx(tx []byte) bool {
-	return strings.HasPrefix(string(tx), 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 subst all the preparetx in the blockdata
-// to null string(could be any arbitrary string).
-func (app *PersistentKVStoreApplication) substPrepareTx(blockData [][]byte) [][]byte {
-	// TODO: this mechanism will change with the current spec of PrepareProposal
-	// We now have a special type for marking a tx as changed
-	for i, tx := range blockData {
-		if isPrepareTx(tx) {
-			blockData[i] = make([]byte, len(tx))
-		}
-	}
-
-	return blockData
-}
-
-func ConstructVoteExtension(valAddr []byte) *ptypes.VoteExtension {
-	return &ptypes.VoteExtension{
-		AppDataToSign:             valAddr,
-		AppDataSelfAuthenticating: valAddr,
-	}
-}
-
-func (app *PersistentKVStoreApplication) verifyExtension(valAddr []byte, ext *ptypes.VoteExtension) bool {
-	if ext == nil {
-		return false
-	}
-	canonical := ConstructVoteExtension(valAddr)
-	if !bytes.Equal(canonical.AppDataToSign, ext.AppDataToSign) {
-		return false
-	}
-	if !bytes.Equal(canonical.AppDataSelfAuthenticating, ext.AppDataSelfAuthenticating) {
-		return false
-	}
-	return true
+	return types.ResponseDeliverTx{Code: code.CodeTypeOK}
 }
--- a/abci/server/grpc_server.go
+++ b/abci/server/grpc_server.go
@@ -58,7 +58,7 @@ func (s *GRPCServer) OnStart(ctx context.Context) error {
 		}()

 		if err := s.server.Serve(s.listener); err != nil {
-			s.logger.Error("error serving gRPC server", "err", err)
+			s.logger.Error("Error serving gRPC server", "err", err)
 		}
 	}()
 	return nil
--- a/abci/server/socket_server.go
+++ b/abci/server/socket_server.go
@@ -61,7 +61,7 @@ func (s *SocketServer) OnStart(ctx context.Context) error {

 func (s *SocketServer) OnStop() {
 	if err := s.listener.Close(); err != nil {
-		s.logger.Error("error closing listener", "err", err)
+		s.logger.Error("Error closing listener", "err", err)
 	}

 	s.connsMtx.Lock()
@@ -70,7 +70,7 @@ func (s *SocketServer) OnStop() {
 	for id, conn := range s.conns {
 		delete(s.conns, id)
 		if err := conn.Close(); err != nil {
-			s.logger.Error("error closing connection", "id", id, "conn", conn, "err", err)
+			s.logger.Error("Error closing connection", "id", id, "conn", conn, "err", err)
 		}
 	}
 }
@@ -139,7 +139,7 @@ func (s *SocketServer) waitForClose(ctx context.Context, closeConn chan error, c
 	defer func() {
 		// Close the connection
 		if err := s.rmConn(connID); err != nil {
-			s.logger.Error("error closing connection", "err", err)
+			s.logger.Error("Error closing connection", "err", err)
 		}
 	}()

@@ -213,6 +213,9 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_Info:
 		res := s.app.Info(*r.Info)
 		responses <- types.ToResponseInfo(res)
+	case *types.Request_DeliverTx:
+		res := s.app.DeliverTx(*r.DeliverTx)
+		responses <- types.ToResponseDeliverTx(res)
 	case *types.Request_CheckTx:
 		res := s.app.CheckTx(*r.CheckTx)
 		responses <- types.ToResponseCheckTx(res)
@@ -225,33 +228,24 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_InitChain:
 		res := s.app.InitChain(*r.InitChain)
 		responses <- types.ToResponseInitChain(res)
+	case *types.Request_BeginBlock:
+		res := s.app.BeginBlock(*r.BeginBlock)
+		responses <- types.ToResponseBeginBlock(res)
+	case *types.Request_EndBlock:
+		res := s.app.EndBlock(*r.EndBlock)
+		responses <- types.ToResponseEndBlock(res)
 	case *types.Request_ListSnapshots:
 		res := s.app.ListSnapshots(*r.ListSnapshots)
 		responses <- types.ToResponseListSnapshots(res)
 	case *types.Request_OfferSnapshot:
 		res := s.app.OfferSnapshot(*r.OfferSnapshot)
 		responses <- types.ToResponseOfferSnapshot(res)
-	case *types.Request_PrepareProposal:
-		res := s.app.PrepareProposal(*r.PrepareProposal)
-		responses <- types.ToResponsePrepareProposal(res)
-	case *types.Request_ProcessProposal:
-		res := s.app.ProcessProposal(*r.ProcessProposal)
-		responses <- types.ToResponseProcessProposal(res)
 	case *types.Request_LoadSnapshotChunk:
 		res := s.app.LoadSnapshotChunk(*r.LoadSnapshotChunk)
 		responses <- types.ToResponseLoadSnapshotChunk(res)
 	case *types.Request_ApplySnapshotChunk:
 		res := s.app.ApplySnapshotChunk(*r.ApplySnapshotChunk)
 		responses <- types.ToResponseApplySnapshotChunk(res)
-	case *types.Request_ExtendVote:
-		res := s.app.ExtendVote(*r.ExtendVote)
-		responses <- types.ToResponseExtendVote(res)
-	case *types.Request_VerifyVoteExtension:
-		res := s.app.VerifyVoteExtension(*r.VerifyVoteExtension)
-		responses <- types.ToResponseVerifyVoteExtension(res)
-	case *types.Request_FinalizeBlock:
-		res := s.app.FinalizeBlock(*r.FinalizeBlock)
-		responses <- types.ToResponseFinalizeBlock(res)
 	default:
 		responses <- types.ToResponseException("Unknown request")
 	}
@@ -265,26 +259,14 @@ func (s *SocketServer) handleResponses(
 	responses <-chan *types.Response,
 ) {
 	bw := bufio.NewWriter(conn)
-	for {
-		select {
-		case <-ctx.Done():
+	for res := range responses {
+		if err := types.WriteMessage(res, bw); err != nil {
+			closeConn <- fmt.Errorf("error writing message: %w", err)
+			return
+		}
+		if err := bw.Flush(); err != nil {
+			closeConn <- fmt.Errorf("error flushing write buffer: %w", err)
 			return
-		case res := <-responses:
-			if err := types.WriteMessage(res, bw); err != nil {
-				select {
-				case <-ctx.Done():
-				case closeConn <- fmt.Errorf("error writing message: %w", err):
-				}
-				return
-			}
-			if err := bw.Flush(); err != nil {
-				select {
-				case <-ctx.Done():
-				case closeConn <- fmt.Errorf("error flushing write buffer: %w", err):
-				}
-
-				return
-			}
 		}
 	}
 }
--- a/abci/tests/client_server_test.go
+++ b/abci/tests/client_server_test.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"

-	"github.com/fortytw2/leaktest"
 	"github.com/stretchr/testify/assert"

 	abciclientent "github.com/tendermint/tendermint/abci/client"
@@ -14,8 +13,6 @@ import (
 )

 func TestClientServerNoAddrPrefix(t *testing.T) {
-	t.Cleanup(leaktest.Check(t))
-
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()

@@ -24,17 +21,15 @@ func TestClientServerNoAddrPrefix(t *testing.T) {
 		transport = "socket"
 	)
 	app := kvstore.NewApplication()
-	logger := log.NewTestingLogger(t)
+	logger := log.TestingLogger()

 	server, err := abciserver.NewServer(logger, addr, transport, app)
 	assert.NoError(t, err, "expected no error on NewServer")
 	err = server.Start(ctx)
 	assert.NoError(t, err, "expected no error on server.Start")
-	t.Cleanup(server.Wait)

 	client, err := abciclientent.NewClient(logger, addr, transport, true)
 	assert.NoError(t, err, "expected no error on NewClient")
 	err = client.Start(ctx)
 	assert.NoError(t, err, "expected no error on client.Start")
-	t.Cleanup(client.Wait)
 }
--- a/abci/tests/server/client.go
+++ b/abci/tests/server/client.go
@@ -21,7 +21,7 @@ func InitChain(ctx context.Context, client abciclient.Client) error {
 		power := mrand.Int()
 		vals[i] = types.UpdateValidator(pubkey, int64(power), "")
 	}
-	_, err := client.InitChain(ctx, types.RequestInitChain{
+	_, err := client.InitChainSync(ctx, types.RequestInitChain{
 		Validators: vals,
 	})
 	if err != nil {
@@ -33,7 +33,7 @@ func InitChain(ctx context.Context, client abciclient.Client) error {
 }

 func Commit(ctx context.Context, client abciclient.Client, hashExp []byte) error {
-	res, err := client.Commit(ctx)
+	res, err := client.CommitSync(ctx)
 	data := res.Data
 	if err != nil {
 		fmt.Println("Failed test: Commit")
@@ -49,29 +49,27 @@ func Commit(ctx context.Context, client abciclient.Client, hashExp []byte) error
 	return nil
 }

-func FinalizeBlock(ctx context.Context, client abciclient.Client, txBytes [][]byte, codeExp []uint32, dataExp []byte) error {
-	res, _ := client.FinalizeBlock(ctx, types.RequestFinalizeBlock{Txs: txBytes})
-	for i, tx := range res.Txs {
-		code, data, log := tx.Code, tx.Data, tx.Log
-		if code != codeExp[i] {
-			fmt.Println("Failed test: FinalizeBlock")
-			fmt.Printf("FinalizeBlock response code was unexpected. Got %v expected %v. Log: %v\n",
-				code, codeExp, log)
-			return errors.New("FinalizeBlock error")
-		}
-		if !bytes.Equal(data, dataExp) {
-			fmt.Println("Failed test:  FinalizeBlock")
-			fmt.Printf("FinalizeBlock response data was unexpected. Got %X expected %X\n",
-				data, dataExp)
-			return errors.New("FinalizeBlock  error")
-		}
+func DeliverTx(ctx context.Context, client abciclient.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
+	res, _ := client.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: txBytes})
+	code, data, log := res.Code, res.Data, res.Log
+	if code != codeExp {
+		fmt.Println("Failed test: DeliverTx")
+		fmt.Printf("DeliverTx response code was unexpected. Got %v expected %v. Log: %v\n",
+			code, codeExp, log)
+		return errors.New("deliverTx error")
 	}
-	fmt.Println("Passed test: FinalizeBlock")
+	if !bytes.Equal(data, dataExp) {
+		fmt.Println("Failed test: DeliverTx")
+		fmt.Printf("DeliverTx response data was unexpected. Got %X expected %X\n",
+			data, dataExp)
+		return errors.New("deliverTx error")
+	}
+	fmt.Println("Passed test: DeliverTx")
 	return nil
 }

 func CheckTx(ctx context.Context, client abciclient.Client, txBytes []byte, codeExp uint32, dataExp []byte) error {
-	res, _ := client.CheckTx(ctx, types.RequestCheckTx{Tx: txBytes})
+	res, _ := client.CheckTxSync(ctx, types.RequestCheckTx{Tx: txBytes})
 	code, data, log := res.Code, res.Data, res.Log
 	if code != codeExp {
 		fmt.Println("Failed test: CheckTx")
--- a/abci/types/application.go
+++ b/abci/types/application.go
@@ -17,17 +17,11 @@ type Application interface {
 	CheckTx(RequestCheckTx) ResponseCheckTx // Validate a tx for the mempool

 	// Consensus Connection
-	InitChain(RequestInitChain) ResponseInitChain // Initialize blockchain w validators/other info from TendermintCore
-	PrepareProposal(RequestPrepareProposal) ResponsePrepareProposal
-	ProcessProposal(RequestProcessProposal) ResponseProcessProposal
-	// Commit the state and return the application Merkle root hash
-	Commit() ResponseCommit
-	// Create application specific vote extension
-	ExtendVote(RequestExtendVote) ResponseExtendVote
-	// Verify application's vote extension data
-	VerifyVoteExtension(RequestVerifyVoteExtension) ResponseVerifyVoteExtension
-	// Deliver the decided block with its txs to the Application
-	FinalizeBlock(RequestFinalizeBlock) ResponseFinalizeBlock
+	InitChain(RequestInitChain) ResponseInitChain    // Initialize blockchain w validators/other info from TendermintCore
+	BeginBlock(RequestBeginBlock) ResponseBeginBlock // Signals the beginning of a block
+	DeliverTx(RequestDeliverTx) ResponseDeliverTx    // Deliver a tx for full processing
+	EndBlock(RequestEndBlock) ResponseEndBlock       // Signals the end of a block, returns changes to the validator set
+	Commit() ResponseCommit                          // Commit the state and return the application Merkle root hash

 	// State Sync Connection
 	ListSnapshots(RequestListSnapshots) ResponseListSnapshots                // List available snapshots
@@ -52,6 +46,10 @@ func (BaseApplication) Info(req RequestInfo) ResponseInfo {
 	return ResponseInfo{}
 }

+func (BaseApplication) DeliverTx(req RequestDeliverTx) ResponseDeliverTx {
+	return ResponseDeliverTx{Code: CodeTypeOK}
+}
+
 func (BaseApplication) CheckTx(req RequestCheckTx) ResponseCheckTx {
 	return ResponseCheckTx{Code: CodeTypeOK}
 }
@@ -60,16 +58,6 @@ func (BaseApplication) Commit() ResponseCommit {
 	return ResponseCommit{}
 }

-func (BaseApplication) ExtendVote(req RequestExtendVote) ResponseExtendVote {
-	return ResponseExtendVote{}
-}
-
-func (BaseApplication) VerifyVoteExtension(req RequestVerifyVoteExtension) ResponseVerifyVoteExtension {
-	return ResponseVerifyVoteExtension{
-		Result: ResponseVerifyVoteExtension_ACCEPT,
-	}
-}
-
 func (BaseApplication) Query(req RequestQuery) ResponseQuery {
 	return ResponseQuery{Code: CodeTypeOK}
 }
@@ -78,6 +66,14 @@ func (BaseApplication) InitChain(req RequestInitChain) ResponseInitChain {
 	return ResponseInitChain{}
 }

+func (BaseApplication) BeginBlock(req RequestBeginBlock) ResponseBeginBlock {
+	return ResponseBeginBlock{}
+}
+
+func (BaseApplication) EndBlock(req RequestEndBlock) ResponseEndBlock {
+	return ResponseEndBlock{}
+}
+
 func (BaseApplication) ListSnapshots(req RequestListSnapshots) ResponseListSnapshots {
 	return ResponseListSnapshots{}
 }
@@ -94,24 +90,6 @@ func (BaseApplication) ApplySnapshotChunk(req RequestApplySnapshotChunk) Respons
 	return ResponseApplySnapshotChunk{}
 }

-func (BaseApplication) PrepareProposal(req RequestPrepareProposal) ResponsePrepareProposal {
-	return ResponsePrepareProposal{}
-}
-
-func (BaseApplication) ProcessProposal(req RequestProcessProposal) ResponseProcessProposal {
-	return ResponseProcessProposal{}
-}
-
-func (BaseApplication) FinalizeBlock(req RequestFinalizeBlock) ResponseFinalizeBlock {
-	txs := make([]*ResponseDeliverTx, len(req.Txs))
-	for i := range req.Txs {
-		txs[i] = &ResponseDeliverTx{Code: CodeTypeOK}
-	}
-	return ResponseFinalizeBlock{
-		Txs: txs,
-	}
-}
-
 //-------------------------------------------------------

 // GRPCApplication is a GRPC wrapper for Application
@@ -136,6 +114,11 @@ func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*Respon
 	return &res, nil
 }

+func (app *GRPCApplication) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) {
+	res := app.app.DeliverTx(*req)
+	return &res, nil
+}
+
 func (app *GRPCApplication) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) {
 	res := app.app.CheckTx(*req)
 	return &res, nil
@@ -156,6 +139,16 @@ func (app *GRPCApplication) InitChain(ctx context.Context, req *RequestInitChain
 	return &res, nil
 }

+func (app *GRPCApplication) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) {
+	res := app.app.BeginBlock(*req)
+	return &res, nil
+}
+
+func (app *GRPCApplication) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) {
+	res := app.app.EndBlock(*req)
+	return &res, nil
+}
+
 func (app *GRPCApplication) ListSnapshots(
 	ctx context.Context, req *RequestListSnapshots) (*ResponseListSnapshots, error) {
 	res := app.app.ListSnapshots(*req)
@@ -179,33 +172,3 @@ func (app *GRPCApplication) ApplySnapshotChunk(
 	res := app.app.ApplySnapshotChunk(*req)
 	return &res, nil
 }
-
-func (app *GRPCApplication) ExtendVote(
-	ctx context.Context, req *RequestExtendVote) (*ResponseExtendVote, error) {
-	res := app.app.ExtendVote(*req)
-	return &res, nil
-}
-
-func (app *GRPCApplication) VerifyVoteExtension(
-	ctx context.Context, req *RequestVerifyVoteExtension) (*ResponseVerifyVoteExtension, error) {
-	res := app.app.VerifyVoteExtension(*req)
-	return &res, nil
-}
-
-func (app *GRPCApplication) PrepareProposal(
-	ctx context.Context, req *RequestPrepareProposal) (*ResponsePrepareProposal, error) {
-	res := app.app.PrepareProposal(*req)
-	return &res, nil
-}
-
-func (app *GRPCApplication) ProcessProposal(
-	ctx context.Context, req *RequestProcessProposal) (*ResponseProcessProposal, error) {
-	res := app.app.ProcessProposal(*req)
-	return &res, nil
-}
-
-func (app *GRPCApplication) FinalizeBlock(
-	ctx context.Context, req *RequestFinalizeBlock) (*ResponseFinalizeBlock, error) {
-	res := app.app.FinalizeBlock(*req)
-	return &res, nil
-}
--- a/abci/types/messages.go
+++ b/abci/types/messages.go
@@ -4,7 +4,6 @@ import (
 	"io"

 	"github.com/gogo/protobuf/proto"
-
 	"github.com/tendermint/tendermint/internal/libs/protoio"
 )

@@ -45,6 +44,12 @@ func ToRequestInfo(req RequestInfo) *Request {
 	}
 }

+func ToRequestDeliverTx(req RequestDeliverTx) *Request {
+	return &Request{
+		Value: &Request_DeliverTx{&req},
+	}
+}
+
 func ToRequestCheckTx(req RequestCheckTx) *Request {
 	return &Request{
 		Value: &Request_CheckTx{&req},
@@ -69,6 +74,18 @@ func ToRequestInitChain(req RequestInitChain) *Request {
 	}
 }

+func ToRequestBeginBlock(req RequestBeginBlock) *Request {
+	return &Request{
+		Value: &Request_BeginBlock{&req},
+	}
+}
+
+func ToRequestEndBlock(req RequestEndBlock) *Request {
+	return &Request{
+		Value: &Request_EndBlock{&req},
+	}
+}
+
 func ToRequestListSnapshots(req RequestListSnapshots) *Request {
 	return &Request{
 		Value: &Request_ListSnapshots{&req},
@@ -93,36 +110,6 @@ func ToRequestApplySnapshotChunk(req RequestApplySnapshotChunk) *Request {
 	}
 }

-func ToRequestExtendVote(req RequestExtendVote) *Request {
-	return &Request{
-		Value: &Request_ExtendVote{&req},
-	}
-}
-
-func ToRequestVerifyVoteExtension(req RequestVerifyVoteExtension) *Request {
-	return &Request{
-		Value: &Request_VerifyVoteExtension{&req},
-	}
-}
-
-func ToRequestPrepareProposal(req RequestPrepareProposal) *Request {
-	return &Request{
-		Value: &Request_PrepareProposal{&req},
-	}
-}
-
-func ToRequestProcessProposal(req RequestProcessProposal) *Request {
-	return &Request{
-		Value: &Request_ProcessProposal{&req},
-	}
-}
-
-func ToRequestFinalizeBlock(req RequestFinalizeBlock) *Request {
-	return &Request{
-		Value: &Request_FinalizeBlock{&req},
-	}
-}
-
 //----------------------------------------

 func ToResponseException(errStr string) *Response {
@@ -148,6 +135,11 @@ func ToResponseInfo(res ResponseInfo) *Response {
 		Value: &Response_Info{&res},
 	}
 }
+func ToResponseDeliverTx(res ResponseDeliverTx) *Response {
+	return &Response{
+		Value: &Response_DeliverTx{&res},
+	}
+}

 func ToResponseCheckTx(res ResponseCheckTx) *Response {
 	return &Response{
@@ -173,6 +165,18 @@ func ToResponseInitChain(res ResponseInitChain) *Response {
 	}
 }

+func ToResponseBeginBlock(res ResponseBeginBlock) *Response {
+	return &Response{
+		Value: &Response_BeginBlock{&res},
+	}
+}
+
+func ToResponseEndBlock(res ResponseEndBlock) *Response {
+	return &Response{
+		Value: &Response_EndBlock{&res},
+	}
+}
+
 func ToResponseListSnapshots(res ResponseListSnapshots) *Response {
 	return &Response{
 		Value: &Response_ListSnapshots{&res},
@@ -196,33 +200,3 @@ func ToResponseApplySnapshotChunk(res ResponseApplySnapshotChunk) *Response {
 		Value: &Response_ApplySnapshotChunk{&res},
 	}
 }
-
-func ToResponseExtendVote(res ResponseExtendVote) *Response {
-	return &Response{
-		Value: &Response_ExtendVote{&res},
-	}
-}
-
-func ToResponseVerifyVoteExtension(res ResponseVerifyVoteExtension) *Response {
-	return &Response{
-		Value: &Response_VerifyVoteExtension{&res},
-	}
-}
-
-func ToResponsePrepareProposal(res ResponsePrepareProposal) *Response {
-	return &Response{
-		Value: &Response_PrepareProposal{&res},
-	}
-}
-
-func ToResponseProcessProposal(res ResponseProcessProposal) *Response {
-	return &Response{
-		Value: &Response_ProcessProposal{&res},
-	}
-}
-
-func ToResponseFinalizeBlock(res ResponseFinalizeBlock) *Response {
-	return &Response{
-		Value: &Response_FinalizeBlock{&res},
-	}
-}
--- a/abci/types/messages_test.go
+++ b/abci/types/messages_test.go
@@ -14,7 +14,7 @@ import (

 func TestMarshalJSON(t *testing.T) {
 	b, err := json.Marshal(&ResponseDeliverTx{})
-	assert.NoError(t, err)
+	assert.Nil(t, err)
 	// include empty fields.
 	assert.True(t, strings.Contains(string(b), "code"))
 	r1 := ResponseCheckTx{
@@ -31,11 +31,11 @@ func TestMarshalJSON(t *testing.T) {
 		},
 	}
 	b, err = json.Marshal(&r1)
-	assert.NoError(t, err)
+	assert.Nil(t, err)

 	var r2 ResponseCheckTx
 	err = json.Unmarshal(b, &r2)
-	assert.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Equal(t, r1, r2)
 }

@@ -49,11 +49,11 @@ func TestWriteReadMessageSimple(t *testing.T) {
 	for _, c := range cases {
 		buf := new(bytes.Buffer)
 		err := WriteMessage(c, buf)
-		assert.NoError(t, err)
+		assert.Nil(t, err)

 		msg := new(RequestEcho)
 		err = ReadMessage(buf, msg)
-		assert.NoError(t, err)
+		assert.Nil(t, err)

 		assert.True(t, proto.Equal(c, msg))
 	}
@@ -71,11 +71,11 @@ func TestWriteReadMessage(t *testing.T) {
 	for _, c := range cases {
 		buf := new(bytes.Buffer)
 		err := WriteMessage(c, buf)
-		assert.NoError(t, err)
+		assert.Nil(t, err)

 		msg := new(tmproto.Header)
 		err = ReadMessage(buf, msg)
-		assert.NoError(t, err)
+		assert.Nil(t, err)

 		assert.True(t, proto.Equal(c, msg))
 	}
@@ -103,11 +103,11 @@ func TestWriteReadMessage2(t *testing.T) {
 	for _, c := range cases {
 		buf := new(bytes.Buffer)
 		err := WriteMessage(c, buf)
-		assert.NoError(t, err)
+		assert.Nil(t, err)

 		msg := new(ResponseCheckTx)
 		err = ReadMessage(buf, msg)
-		assert.NoError(t, err)
+		assert.Nil(t, err)

 		assert.True(t, proto.Equal(c, msg))
 	}
--- a/abci/types/result.go
+++ b/abci/types/result.go
@@ -5,8 +5,6 @@ import (
 	"encoding/json"

 	"github.com/gogo/protobuf/jsonpb"
-
-	types "github.com/tendermint/tendermint/proto/tendermint/types"
 )

 const (
@@ -43,26 +41,6 @@ func (r ResponseQuery) IsErr() bool {
 	return r.Code != CodeTypeOK
 }

-// IsUnknown returns true if Code is Unknown
-func (r ResponseVerifyVoteExtension) IsUnknown() bool {
-	return r.Result == ResponseVerifyVoteExtension_UNKNOWN
-}
-
-// IsOK returns true if Code is OK
-func (r ResponseVerifyVoteExtension) IsOK() bool {
-	return r.Result == ResponseVerifyVoteExtension_ACCEPT
-}
-
-// IsErr returns true if Code is something other than OK.
-func (r ResponseVerifyVoteExtension) IsErr() bool {
-	return r.Result != ResponseVerifyVoteExtension_ACCEPT
-}
-
-// IsOK returns true if Code is OK
-func (r ResponseProcessProposal) IsOK() bool {
-	return r.Result == ResponseProcessProposal_ACCEPT
-}
-
 //---------------------------------------------------------------------------
 // override JSON marshaling so we emit defaults (ie. disable omitempty)

@@ -140,25 +118,3 @@ var _ jsonRoundTripper = (*ResponseDeliverTx)(nil)
 var _ jsonRoundTripper = (*ResponseCheckTx)(nil)

 var _ jsonRoundTripper = (*EventAttribute)(nil)
-
-// -----------------------------------------------
-// construct Result data
-
-func RespondExtendVote(appDataToSign, appDataSelfAuthenticating []byte) ResponseExtendVote {
-	return ResponseExtendVote{
-		VoteExtension: &types.VoteExtension{
-			AppDataToSign:             appDataToSign,
-			AppDataSelfAuthenticating: appDataSelfAuthenticating,
-		},
-	}
-}
-
-func RespondVerifyVoteExtension(ok bool) ResponseVerifyVoteExtension {
-	result := ResponseVerifyVoteExtension_REJECT
-	if ok {
-		result = ResponseVerifyVoteExtension_ACCEPT
-	}
-	return ResponseVerifyVoteExtension{
-		Result: result,
-	}
-}
--- a/abci/types/types.pb.go
+++ b/abci/types/types.pb.go
--- a/abci/version/version.go
+++ b/abci/version/version.go
@@ -0,0 +1,9 @@
+package version
+
+import (
+	"github.com/tendermint/tendermint/version"
+)
+
+// TODO: eliminate this after some version refactor
+
+const Version = version.ABCIVersion
--- a/buf.gen.yaml
+++ b/buf.gen.yaml
@@ -1,14 +0,0 @@
-# The version of the generation template (required).
-# The only currently-valid value is v1beta1.
-version: v1beta1
-
-# The plugins to run.
-plugins:
-  # The name of the plugin.
-  - name: gogofaster
-    # The directory where the generated proto output will be written.
-    # The directory is relative to where the generation tool was run.
-    out: proto
-    # Set options to assign import paths to the well-known types
-    # and to enable service generation.
-    opt: Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,plugins=grpc,paths=source_relative
--- a/buf.yaml
+++ b/buf.yaml
@@ -1,16 +0,0 @@
-version: v1beta1
-
-build:
-  roots:
-    - proto
-    - third_party/proto
-lint:
-  use:
-    - BASIC
-    - FILE_LOWER_SNAKE_CASE
-    - UNARY_RPC
-  ignore:
-    - gogoproto
-breaking:
-  use:
-    - FILE
--- a/cmd/priv_val_server/main.go
+++ b/cmd/priv_val_server/main.go
@@ -9,8 +9,6 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"os/signal"
-	"syscall"
 	"time"

 	grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus"
@@ -21,6 +19,7 @@ import (

 	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
+	tmos "github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/privval"
 	grpcprivval "github.com/tendermint/tendermint/privval/grpc"
 	privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval"
@@ -45,16 +44,12 @@ func main() {
 		keyFile          = flag.String("keyfile", "", "absolute path to server key")
 		rootCA           = flag.String("rootcafile", "", "absolute path to root CA")
 		prometheusAddr   = flag.String("prometheus-addr", "", "address for prometheus endpoint (host:port)")
+
+		logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false).
+			With("module", "priv_val")
 	)
 	flag.Parse()

-	logger, err := log.NewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "failed to construct logger: %v", err)
-		os.Exit(1)
-	}
-	logger = logger.With("module", "priv_val")
-
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()

@@ -138,10 +133,9 @@ func main() {
 		os.Exit(1)
 	}

-	opctx, opcancel := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
-	defer opcancel()
-	go func() {
-		<-opctx.Done()
+	// Stop upon receiving SIGTERM or CTRL-C.
+	tmos.TrapSignal(ctx, logger, func() {
+		logger.Debug("SignerServer: calling Close")
 		if *prometheusAddr != "" {
 			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
 			defer cancel()
@@ -151,7 +145,7 @@ func main() {
 			}
 		}
 		s.GracefulStop()
-	}()
+	})

 	// Run forever.
 	select {}
--- a/cmd/tendermint/commands/completion.go
+++ b/cmd/tendermint/commands/completion.go
@@ -1,46 +0,0 @@
-package commands
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-)
-
-// NewCompletionCmd returns a cobra.Command that generates bash and zsh
-// completion scripts for the given root command. If hidden is true, the
-// command will not show up in the root command's list of available commands.
-func NewCompletionCmd(rootCmd *cobra.Command, hidden bool) *cobra.Command {
-	flagZsh := "zsh"
-	cmd := &cobra.Command{
-		Use:   "completion",
-		Short: "Generate shell completion scripts",
-		Long: fmt.Sprintf(`Generate Bash and Zsh completion scripts and print them to STDOUT.
-
-Once saved to file, a completion script can be loaded in the shell's
-current session as shown:
-
-   $ . <(%s completion)
-
-To configure your bash shell to load completions for each session add to
-your $HOME/.bashrc or $HOME/.profile the following instruction:
-
-   . <(%s completion)
-`, rootCmd.Use, rootCmd.Use),
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			zsh, err := cmd.Flags().GetBool(flagZsh)
-			if err != nil {
-				return err
-			}
-			if zsh {
-				return rootCmd.GenZshCompletion(cmd.OutOrStdout())
-			}
-			return rootCmd.GenBashCompletion(cmd.OutOrStdout())
-		},
-		Hidden: hidden,
-		Args:   cobra.NoArgs,
-	}
-
-	cmd.Flags().Bool(flagZsh, false, "Generate Zsh completion script")
-
-	return cmd
-}
--- a/cmd/tendermint/commands/debug/debug.go
+++ b/cmd/tendermint/commands/debug/debug.go
@@ -15,7 +15,7 @@ var (
 	flagProfAddr    = "pprof-laddr"
 	flagFrequency   = "frequency"

-	logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo)
+	logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
 )

 // DebugCmd defines the root command containing subcommands that assist in
--- a/cmd/tendermint/commands/debug/dump.go
+++ b/cmd/tendermint/commands/debug/dump.go
@@ -1,7 +1,6 @@
 package debug

 import (
-	"context"
 	"errors"
 	"fmt"
 	"os"
@@ -43,7 +42,7 @@ func init() {
 	)
 }

-func dumpCmdHandler(cmd *cobra.Command, args []string) error {
+func dumpCmdHandler(_ *cobra.Command, args []string) error {
 	outDir := args[0]
 	if outDir == "" {
 		return errors.New("invalid output directory")
@@ -64,24 +63,22 @@ func dumpCmdHandler(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("failed to create new http client: %w", err)
 	}

-	ctx := cmd.Context()
-
 	home := viper.GetString(cli.HomeFlag)
 	conf := config.DefaultConfig()
 	conf = conf.SetRoot(home)
 	config.EnsureRoot(conf.RootDir)

-	dumpDebugData(ctx, outDir, conf, rpc)
+	dumpDebugData(outDir, conf, rpc)

 	ticker := time.NewTicker(time.Duration(frequency) * time.Second)
 	for range ticker.C {
-		dumpDebugData(ctx, outDir, conf, rpc)
+		dumpDebugData(outDir, conf, rpc)
 	}

 	return nil
 }

-func dumpDebugData(ctx context.Context, outDir string, conf *config.Config, rpc *rpchttp.HTTP) {
+func dumpDebugData(outDir string, conf *config.Config, rpc *rpchttp.HTTP) {
 	start := time.Now().UTC()

 	tmpDir, err := os.MkdirTemp(outDir, "tendermint_debug_tmp")
@@ -92,19 +89,19 @@ func dumpDebugData(ctx context.Context, outDir string, conf *config.Config, rpc
 	defer os.RemoveAll(tmpDir)

 	logger.Info("getting node status...")
-	if err := dumpStatus(ctx, rpc, tmpDir, "status.json"); err != nil {
+	if err := dumpStatus(rpc, tmpDir, "status.json"); err != nil {
 		logger.Error("failed to dump node status", "error", err)
 		return
 	}

 	logger.Info("getting node network info...")
-	if err := dumpNetInfo(ctx, rpc, tmpDir, "net_info.json"); err != nil {
+	if err := dumpNetInfo(rpc, tmpDir, "net_info.json"); err != nil {
 		logger.Error("failed to dump node network info", "error", err)
 		return
 	}

 	logger.Info("getting node consensus state...")
-	if err := dumpConsensusState(ctx, rpc, tmpDir, "consensus_state.json"); err != nil {
+	if err := dumpConsensusState(rpc, tmpDir, "consensus_state.json"); err != nil {
 		logger.Error("failed to dump node consensus state", "error", err)
 		return
 	}
--- a/cmd/tendermint/commands/debug/kill.go
+++ b/cmd/tendermint/commands/debug/kill.go
@@ -33,7 +33,6 @@ $ tendermint debug kill 34255 /path/to/tm-debug.zip`,
 }

 func killCmdHandler(cmd *cobra.Command, args []string) error {
-	ctx := cmd.Context()
 	pid, err := strconv.ParseInt(args[0], 10, 64)
 	if err != nil {
 		return err
@@ -63,17 +62,17 @@ func killCmdHandler(cmd *cobra.Command, args []string) error {
 	defer os.RemoveAll(tmpDir)

 	logger.Info("getting node status...")
-	if err := dumpStatus(ctx, rpc, tmpDir, "status.json"); err != nil {
+	if err := dumpStatus(rpc, tmpDir, "status.json"); err != nil {
 		return err
 	}

 	logger.Info("getting node network info...")
-	if err := dumpNetInfo(ctx, rpc, tmpDir, "net_info.json"); err != nil {
+	if err := dumpNetInfo(rpc, tmpDir, "net_info.json"); err != nil {
 		return err
 	}

 	logger.Info("getting node consensus state...")
-	if err := dumpConsensusState(ctx, rpc, tmpDir, "consensus_state.json"); err != nil {
+	if err := dumpConsensusState(rpc, tmpDir, "consensus_state.json"); err != nil {
 		return err
 	}

--- a/cmd/tendermint/commands/debug/util.go
+++ b/cmd/tendermint/commands/debug/util.go
@@ -15,8 +15,8 @@ import (

 // dumpStatus gets node status state dump from the Tendermint RPC and writes it
 // to file. It returns an error upon failure.
-func dumpStatus(ctx context.Context, rpc *rpchttp.HTTP, dir, filename string) error {
-	status, err := rpc.Status(ctx)
+func dumpStatus(rpc *rpchttp.HTTP, dir, filename string) error {
+	status, err := rpc.Status(context.Background())
 	if err != nil {
 		return fmt.Errorf("failed to get node status: %w", err)
 	}
@@ -26,8 +26,8 @@ func dumpStatus(ctx context.Context, rpc *rpchttp.HTTP, dir, filename string) er

 // dumpNetInfo gets network information state dump from the Tendermint RPC and
 // writes it to file. It returns an error upon failure.
-func dumpNetInfo(ctx context.Context, rpc *rpchttp.HTTP, dir, filename string) error {
-	netInfo, err := rpc.NetInfo(ctx)
+func dumpNetInfo(rpc *rpchttp.HTTP, dir, filename string) error {
+	netInfo, err := rpc.NetInfo(context.Background())
 	if err != nil {
 		return fmt.Errorf("failed to get node network information: %w", err)
 	}
@@ -37,8 +37,8 @@ func dumpNetInfo(ctx context.Context, rpc *rpchttp.HTTP, dir, filename string) e

 // dumpConsensusState gets consensus state dump from the Tendermint RPC and
 // writes it to file. It returns an error upon failure.
-func dumpConsensusState(ctx context.Context, rpc *rpchttp.HTTP, dir, filename string) error {
-	consDump, err := rpc.DumpConsensusState(ctx)
+func dumpConsensusState(rpc *rpchttp.HTTP, dir, filename string) error {
+	consDump, err := rpc.DumpConsensusState(context.Background())
 	if err != nil {
 		return fmt.Errorf("failed to get node consensus dump: %w", err)
 	}
--- a/cmd/tendermint/commands/gen_node_key.go
+++ b/cmd/tendermint/commands/gen_node_key.go
@@ -1,11 +1,11 @@
 package commands

 import (
-	"encoding/json"
 	"fmt"

 	"github.com/spf13/cobra"

+	tmjson "github.com/tendermint/tendermint/libs/json"
 	"github.com/tendermint/tendermint/types"
 )

@@ -20,7 +20,7 @@ var GenNodeKeyCmd = &cobra.Command{
 func genNodeKey(cmd *cobra.Command, args []string) error {
 	nodeKey := types.GenNodeKey()

-	bz, err := json.Marshal(nodeKey)
+	bz, err := tmjson.Marshal(nodeKey)
 	if err != nil {
 		return fmt.Errorf("nodeKey -> json: %w", err)
 	}
--- a/cmd/tendermint/commands/gen_validator.go
+++ b/cmd/tendermint/commands/gen_validator.go
@@ -1,41 +1,41 @@
 package commands

 import (
-	"encoding/json"
 	"fmt"

 	"github.com/spf13/cobra"

+	tmjson "github.com/tendermint/tendermint/libs/json"
 	"github.com/tendermint/tendermint/privval"
 	"github.com/tendermint/tendermint/types"
 )

 // GenValidatorCmd allows the generation of a keypair for a
 // validator.
-func MakeGenValidatorCommand() *cobra.Command {
-	var keyType string
-	cmd := &cobra.Command{
-		Use:   "gen-validator",
-		Short: "Generate new validator keypair",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			pv, err := privval.GenFilePV("", "", keyType)
-			if err != nil {
-				return err
-			}
+var GenValidatorCmd = &cobra.Command{
+	Use:   "gen-validator",
+	Short: "Generate new validator keypair",
+	RunE:  genValidator,
+}

-			jsbz, err := json.Marshal(pv)
-			if err != nil {
-				return fmt.Errorf("validator -> json: %w", err)
-			}
+func init() {
+	GenValidatorCmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
+		"Key type to generate privval file with. Options: ed25519, secp256k1")
+}

-			fmt.Printf("%v\n", string(jsbz))
-
-			return nil
-		},
+func genValidator(cmd *cobra.Command, args []string) error {
+	pv, err := privval.GenFilePV("", "", keyType)
+	if err != nil {
+		return err
 	}

-	cmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
-		"Key type to generate privval file with. Options: ed25519, secp256k1")
+	jsbz, err := tmjson.Marshal(pv)
+	if err != nil {
+		return fmt.Errorf("validator -> json: %w", err)
+	}

-	return cmd
+	fmt.Printf(`%v
+`, string(jsbz))
+
+	return nil
 }
--- a/cmd/tendermint/commands/init.go
+++ b/cmd/tendermint/commands/init.go
@@ -7,8 +7,7 @@ import (

 	"github.com/spf13/cobra"

-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/libs/log"
+	cfg "github.com/tendermint/tendermint/config"
 	tmos "github.com/tendermint/tendermint/libs/os"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmtime "github.com/tendermint/tendermint/libs/time"
@@ -16,40 +15,43 @@ import (
 	"github.com/tendermint/tendermint/types"
 )

-// MakeInitFilesCommand returns the command to initialize a fresh Tendermint Core instance.
-func MakeInitFilesCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	var keyType string
-	cmd := &cobra.Command{
-		Use:       "init [full|validator|seed]",
-		Short:     "Initializes a Tendermint node",
-		ValidArgs: []string{"full", "validator", "seed"},
-		// We allow for zero args so we can throw a more informative error
-		Args: cobra.MaximumNArgs(1),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			if len(args) == 0 {
-				return errors.New("must specify a node type: tendermint init [validator|full|seed]")
-			}
-			conf.Mode = args[0]
-			return initFilesWithConfig(cmd.Context(), conf, logger, keyType)
-		},
-	}
-
-	cmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
-		"Key type to generate privval file with. Options: ed25519, secp256k1")
-
-	return cmd
+// InitFilesCmd initializes a fresh Tendermint Core instance.
+var InitFilesCmd = &cobra.Command{
+	Use:       "init [full|validator|seed]",
+	Short:     "Initializes a Tendermint node",
+	ValidArgs: []string{"full", "validator", "seed"},
+	// We allow for zero args so we can throw a more informative error
+	Args: cobra.MaximumNArgs(1),
+	RunE: initFiles,
 }

-func initFilesWithConfig(ctx context.Context, conf *config.Config, logger log.Logger, keyType string) error {
+var (
+	keyType string
+)
+
+func init() {
+	InitFilesCmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
+		"Key type to generate privval file with. Options: ed25519, secp256k1")
+}
+
+func initFiles(cmd *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return errors.New("must specify a node type: tendermint init [validator|full|seed]")
+	}
+	config.Mode = args[0]
+	return initFilesWithConfig(config)
+}
+
+func initFilesWithConfig(config *cfg.Config) error {
 	var (
 		pv  *privval.FilePV
 		err error
 	)

-	if conf.Mode == config.ModeValidator {
+	if config.Mode == cfg.ModeValidator {
 		// private validator
-		privValKeyFile := conf.PrivValidator.KeyFile()
-		privValStateFile := conf.PrivValidator.StateFile()
+		privValKeyFile := config.PrivValidator.KeyFile()
+		privValStateFile := config.PrivValidator.StateFile()
 		if tmos.FileExists(privValKeyFile) {
 			pv, err = privval.LoadFilePV(privValKeyFile, privValStateFile)
 			if err != nil {
@@ -63,15 +65,13 @@ func initFilesWithConfig(ctx context.Context, conf *config.Config, logger log.Lo
 			if err != nil {
 				return err
 			}
-			if err := pv.Save(); err != nil {
-				return err
-			}
+			pv.Save()
 			logger.Info("Generated private validator", "keyFile", privValKeyFile,
 				"stateFile", privValStateFile)
 		}
 	}

-	nodeKeyFile := conf.NodeKeyFile()
+	nodeKeyFile := config.NodeKeyFile()
 	if tmos.FileExists(nodeKeyFile) {
 		logger.Info("Found node key", "path", nodeKeyFile)
 	} else {
@@ -82,7 +82,7 @@ func initFilesWithConfig(ctx context.Context, conf *config.Config, logger log.Lo
 	}

 	// genesis file
-	genFile := conf.GenesisFile()
+	genFile := config.GenesisFile()
 	if tmos.FileExists(genFile) {
 		logger.Info("Found genesis file", "path", genFile)
 	} else {
@@ -98,7 +98,7 @@ func initFilesWithConfig(ctx context.Context, conf *config.Config, logger log.Lo
 			}
 		}

-		ctx, cancel := context.WithTimeout(ctx, ctxTimeout)
+		ctx, cancel := context.WithTimeout(context.TODO(), ctxTimeout)
 		defer cancel()

 		// if this is a validator we add it to genesis
@@ -121,10 +121,10 @@ func initFilesWithConfig(ctx context.Context, conf *config.Config, logger log.Lo
 	}

 	// write config file
-	if err := config.WriteConfigFile(conf.RootDir, conf); err != nil {
+	if err := cfg.WriteConfigFile(config.RootDir, config); err != nil {
 		return err
 	}
-	logger.Info("Generated config", "mode", conf.Mode)
+	logger.Info("Generated config", "mode", config.Mode)

 	return nil
 }
--- a/cmd/tendermint/commands/inspect.go
+++ b/cmd/tendermint/commands/inspect.go
@@ -6,17 +6,14 @@ import (

 	"github.com/spf13/cobra"

-	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/inspect"
-	"github.com/tendermint/tendermint/libs/log"
 )

-// InspectCmd constructs the command to start an inspect server.
-func MakeInspectCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "inspect",
-		Short: "Run an inspect server for investigating Tendermint state",
-		Long: `
+// InspectCmd is the command for starting an inspect server.
+var InspectCmd = &cobra.Command{
+	Use:   "inspect",
+	Short: "Run an inspect server for investigating Tendermint state",
+	Long: `
 	inspect runs a subset of Tendermint's RPC endpoints that are useful for debugging
 	issues with Tendermint.

@@ -25,27 +22,33 @@ func MakeInspectCommand(conf *config.Config, logger log.Logger) *cobra.Command {
 	The inspect command can be used to query the block and state store using Tendermint
 	RPC calls to debug issues of inconsistent state.
 	`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM, syscall.SIGINT)
-			defer cancel()

-			ins, err := inspect.NewFromConfig(logger, conf)
-			if err != nil {
-				return err
-			}
-
-			logger.Info("starting inspect server")
-			if err := ins.Run(ctx); err != nil {
-				return err
-			}
-			return nil
-		},
-	}
-	cmd.Flags().String("rpc.laddr",
-		conf.RPC.ListenAddress, "RPC listenener address. Port required")
-	cmd.Flags().String("db-backend",
-		conf.DBBackend, "database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb")
-	cmd.Flags().String("db-dir", conf.DBPath, "database directory")
-
-	return cmd
+	RunE: runInspect,
+}
+
+func init() {
+	InspectCmd.Flags().
+		String("rpc.laddr",
+			config.RPC.ListenAddress, "RPC listenener address. Port required")
+	InspectCmd.Flags().
+		String("db-backend",
+			config.DBBackend, "database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb")
+	InspectCmd.Flags().
+		String("db-dir", config.DBPath, "database directory")
+}
+
+func runInspect(cmd *cobra.Command, args []string) error {
+	ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM, syscall.SIGINT)
+	defer cancel()
+
+	ins, err := inspect.NewFromConfig(logger, config)
+	if err != nil {
+		return err
+	}
+
+	logger.Info("starting inspect server")
+	if err := ins.Run(ctx); err != nil {
+		return err
+	}
+	return nil
 }
--- a/cmd/tendermint/commands/key_migrate.go
+++ b/cmd/tendermint/commands/key_migrate.go
@@ -5,13 +5,11 @@ import (
 	"fmt"

 	"github.com/spf13/cobra"
-
 	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/scripts/keymigrate"
 )

-func MakeKeyMigrateCommand(conf *cfg.Config, logger log.Logger) *cobra.Command {
+func MakeKeyMigrateCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "key-migrate",
 		Short: "Run Database key migration",
@@ -40,7 +38,7 @@ func MakeKeyMigrateCommand(conf *cfg.Config, logger log.Logger) *cobra.Command {

 				db, err := cfg.DefaultDBProvider(&cfg.DBContext{
 					ID:     dbctx,
-					Config: conf,
+					Config: config,
 				})

 				if err != nil {
@@ -60,7 +58,7 @@ func MakeKeyMigrateCommand(conf *cfg.Config, logger log.Logger) *cobra.Command {
 	}

 	// allow database info to be overridden via cli
-	addDBFlags(cmd, conf)
+	addDBFlags(cmd)

 	return cmd
 }
--- a/cmd/tendermint/commands/light.go
+++ b/cmd/tendermint/commands/light.go
@@ -15,9 +15,9 @@ import (
 	"github.com/spf13/cobra"
 	dbm "github.com/tendermint/tm-db"

-	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	tmmath "github.com/tendermint/tendermint/libs/math"
+	tmos "github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/light"
 	lproxy "github.com/tendermint/tendermint/light/proxy"
 	lrpc "github.com/tendermint/tendermint/light/rpc"
@@ -25,69 +25,20 @@ import (
 	rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server"
 )

-// LightCmd constructs the base command called when invoked without any subcommands.
-func MakeLightCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	var (
-		listenAddr         string
-		primaryAddr        string
-		witnessAddrsJoined string
-		chainID            string
-		dir                string
-		maxOpenConnections int
-
-		sequential     bool
-		trustingPeriod time.Duration
-		trustedHeight  int64
-		trustedHash    []byte
-		trustLevelStr  string
-
-		logLevel  string
-		logFormat string
-
-		primaryKey   = []byte("primary")
-		witnessesKey = []byte("witnesses")
-	)
-
-	checkForExistingProviders := func(db dbm.DB) (string, []string, error) {
-		primaryBytes, err := db.Get(primaryKey)
-		if err != nil {
-			return "", []string{""}, err
-		}
-		witnessesBytes, err := db.Get(witnessesKey)
-		if err != nil {
-			return "", []string{""}, err
-		}
-		witnessesAddrs := strings.Split(string(witnessesBytes), ",")
-		return string(primaryBytes), witnessesAddrs, nil
-	}
-
-	saveProviders := func(db dbm.DB, primaryAddr, witnessesAddrs string) error {
-		err := db.Set(primaryKey, []byte(primaryAddr))
-		if err != nil {
-			return fmt.Errorf("failed to save primary provider: %w", err)
-		}
-		err = db.Set(witnessesKey, []byte(witnessesAddrs))
-		if err != nil {
-			return fmt.Errorf("failed to save witness providers: %w", err)
-		}
-		return nil
-	}
-
-	cmd := &cobra.Command{
-		Use:   "light [chainID]",
-		Short: "Run a light client proxy server, verifying Tendermint rpc",
-		Long: `Run a light client proxy server, verifying Tendermint rpc.
+// LightCmd represents the base command when called without any subcommands
+var LightCmd = &cobra.Command{
+	Use:   "light [chainID]",
+	Short: "Run a light client proxy server, verifying Tendermint rpc",
+	Long: `Run a light client proxy server, verifying Tendermint rpc.

 All calls that can be tracked back to a block header by a proof
 will be verified before passing them back to the caller. Other than
 that, it will present the same interface as a full Tendermint node.

 Furthermore to the chainID, a fresh instance of a light client will
-need a primary RPC address and a trusted hash and height. It is also highly
-recommended to provide additional witness RPC addresses, especially if
-not using sequential verification.
-
-To restart the node, thereafter only the chainID is required.
+need a primary RPC address, a trusted hash and height and witness RPC addresses
+(if not using sequential verification). To restart the node, thereafter
+only the chainID is required.

 When /abci_query is called, the Merkle key path format is:

@@ -96,138 +47,186 @@ When /abci_query is called, the Merkle key path format is:
 Please verify with your application that this Merkle key format is used (true
 for applications built w/ Cosmos SDK).
 `,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			chainID = args[0]
-			logger.Info("Creating client...", "chainID", chainID)
-
-			var witnessesAddrs []string
-			if witnessAddrsJoined != "" {
-				witnessesAddrs = strings.Split(witnessAddrsJoined, ",")
-			}
-
-			lightDB, err := dbm.NewGoLevelDB("light-client-db", dir)
-			if err != nil {
-				return fmt.Errorf("can't create a db: %w", err)
-			}
-			// create a prefixed db on the chainID
-			db := dbm.NewPrefixDB(lightDB, []byte(chainID))
-
-			if primaryAddr == "" { // check to see if we can start from an existing state
-				var err error
-				primaryAddr, witnessesAddrs, err = checkForExistingProviders(db)
-				if err != nil {
-					return fmt.Errorf("failed to retrieve primary or witness from db: %w", err)
-				}
-				if primaryAddr == "" {
-					return errors.New("no primary address was provided nor found. Please provide a primary (using -p)." +
-						" Run the command: tendermint light --help for more information")
-				}
-			} else {
-				err := saveProviders(db, primaryAddr, witnessAddrsJoined)
-				if err != nil {
-					logger.Error("Unable to save primary and or witness addresses", "err", err)
-				}
-			}
-
-			if len(witnessesAddrs) < 1 && !sequential {
-				logger.Info("In skipping verification mode it is highly recommended to provide at least one witness")
-			}
-
-			trustLevel, err := tmmath.ParseFraction(trustLevelStr)
-			if err != nil {
-				return fmt.Errorf("can't parse trust level: %w", err)
-			}
-
-			options := []light.Option{light.Logger(logger)}
-
-			vo := light.SkippingVerification(trustLevel)
-			if sequential {
-				vo = light.SequentialVerification()
-			}
-			options = append(options, vo)
-
-			// Initiate the light client. If the trusted store already has blocks in it, this
-			// will be used else we use the trusted options.
-			c, err := light.NewHTTPClient(
-				context.Background(),
-				chainID,
-				light.TrustOptions{
-					Period: trustingPeriod,
-					Height: trustedHeight,
-					Hash:   trustedHash,
-				},
-				primaryAddr,
-				witnessesAddrs,
-				dbs.New(db),
-				options...,
-			)
-			if err != nil {
-				return err
-			}
-
-			cfg := rpcserver.DefaultConfig()
-			cfg.MaxBodyBytes = conf.RPC.MaxBodyBytes
-			cfg.MaxHeaderBytes = conf.RPC.MaxHeaderBytes
-			cfg.MaxOpenConnections = maxOpenConnections
-			// If necessary adjust global WriteTimeout to ensure it's greater than
-			// TimeoutBroadcastTxCommit.
-			// See https://github.com/tendermint/tendermint/issues/3435
-			if cfg.WriteTimeout <= conf.RPC.TimeoutBroadcastTxCommit {
-				cfg.WriteTimeout = conf.RPC.TimeoutBroadcastTxCommit + 1*time.Second
-			}
-
-			p, err := lproxy.NewProxy(c, listenAddr, primaryAddr, cfg, logger, lrpc.KeyPathFn(lrpc.DefaultMerkleKeyPathFn()))
-			if err != nil {
-				return err
-			}
-
-			ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM)
-			defer cancel()
-
-			go func() {
-				<-ctx.Done()
-				p.Listener.Close()
-			}()
-
-			logger.Info("Starting proxy...", "laddr", listenAddr)
-			if err := p.ListenAndServe(ctx); err != http.ErrServerClosed {
-				// Error starting or closing listener:
-				logger.Error("proxy ListenAndServe", "err", err)
-			}
-
-			return nil
-		},
-		Args: cobra.ExactArgs(1),
-		Example: `light cosmoshub-3 -p http://52.57.29.196:26657 -w http://public-seed-node.cosmoshub.certus.one:26657
+	RunE: runProxy,
+	Args: cobra.ExactArgs(1),
+	Example: `light cosmoshub-3 -p http://52.57.29.196:26657 -w http://public-seed-node.cosmoshub.certus.one:26657
 	--height 962118 --hash 28B97BE9F6DE51AC69F70E0B7BFD7E5C9CD1A595B7DC31AFF27C50D4948020CD`,
-	}
+}

-	cmd.Flags().StringVar(&listenAddr, "laddr", "tcp://localhost:8888",
+var (
+	listenAddr         string
+	primaryAddr        string
+	witnessAddrsJoined string
+	chainID            string
+	dir                string
+	maxOpenConnections int
+
+	sequential     bool
+	trustingPeriod time.Duration
+	trustedHeight  int64
+	trustedHash    []byte
+	trustLevelStr  string
+
+	logLevel  string
+	logFormat string
+
+	primaryKey   = []byte("primary")
+	witnessesKey = []byte("witnesses")
+)
+
+func init() {
+	LightCmd.Flags().StringVar(&listenAddr, "laddr", "tcp://localhost:8888",
 		"serve the proxy on the given address")
-	cmd.Flags().StringVarP(&primaryAddr, "primary", "p", "",
+	LightCmd.Flags().StringVarP(&primaryAddr, "primary", "p", "",
 		"connect to a Tendermint node at this address")
-	cmd.Flags().StringVarP(&witnessAddrsJoined, "witnesses", "w", "",
+	LightCmd.Flags().StringVarP(&witnessAddrsJoined, "witnesses", "w", "",
 		"tendermint nodes to cross-check the primary node, comma-separated")
-	cmd.Flags().StringVarP(&dir, "dir", "d", os.ExpandEnv(filepath.Join("$HOME", ".tendermint-light")),
+	LightCmd.Flags().StringVarP(&dir, "dir", "d", os.ExpandEnv(filepath.Join("$HOME", ".tendermint-light")),
 		"specify the directory")
-	cmd.Flags().IntVar(
+	LightCmd.Flags().IntVar(
 		&maxOpenConnections,
 		"max-open-connections",
 		900,
 		"maximum number of simultaneous connections (including WebSocket).")
-	cmd.Flags().DurationVar(&trustingPeriod, "trusting-period", 168*time.Hour,
+	LightCmd.Flags().DurationVar(&trustingPeriod, "trusting-period", 168*time.Hour,
 		"trusting period that headers can be verified within. Should be significantly less than the unbonding period")
-	cmd.Flags().Int64Var(&trustedHeight, "height", 1, "Trusted header's height")
-	cmd.Flags().BytesHexVar(&trustedHash, "hash", []byte{}, "Trusted header's hash")
-	cmd.Flags().StringVar(&logLevel, "log-level", log.LogLevelInfo, "The logging level (debug|info|warn|error|fatal)")
-	cmd.Flags().StringVar(&logFormat, "log-format", log.LogFormatPlain, "The logging format (text|json)")
-	cmd.Flags().StringVar(&trustLevelStr, "trust-level", "1/3",
+	LightCmd.Flags().Int64Var(&trustedHeight, "height", 1, "Trusted header's height")
+	LightCmd.Flags().BytesHexVar(&trustedHash, "hash", []byte{}, "Trusted header's hash")
+	LightCmd.Flags().StringVar(&logLevel, "log-level", log.LogLevelInfo, "The logging level (debug|info|warn|error|fatal)")
+	LightCmd.Flags().StringVar(&logFormat, "log-format", log.LogFormatPlain, "The logging format (text|json)")
+	LightCmd.Flags().StringVar(&trustLevelStr, "trust-level", "1/3",
 		"trust level. Must be between 1/3 and 3/3",
 	)
-	cmd.Flags().BoolVar(&sequential, "sequential", false,
+	LightCmd.Flags().BoolVar(&sequential, "sequential", false,
 		"sequential verification. Verify all headers sequentially as opposed to using skipping verification",
 	)
-
-	return cmd
-
+}
+
+func runProxy(cmd *cobra.Command, args []string) error {
+	logger, err := log.NewDefaultLogger(logFormat, logLevel, false)
+	if err != nil {
+		return err
+	}
+
+	chainID = args[0]
+	logger.Info("Creating client...", "chainID", chainID)
+
+	witnessesAddrs := []string{}
+	if witnessAddrsJoined != "" {
+		witnessesAddrs = strings.Split(witnessAddrsJoined, ",")
+	}
+
+	lightDB, err := dbm.NewGoLevelDB("light-client-db", dir)
+	if err != nil {
+		return fmt.Errorf("can't create a db: %w", err)
+	}
+	// create a prefixed db on the chainID
+	db := dbm.NewPrefixDB(lightDB, []byte(chainID))
+
+	if primaryAddr == "" { // check to see if we can start from an existing state
+		var err error
+		primaryAddr, witnessesAddrs, err = checkForExistingProviders(db)
+		if err != nil {
+			return fmt.Errorf("failed to retrieve primary or witness from db: %w", err)
+		}
+		if primaryAddr == "" {
+			return errors.New("no primary address was provided nor found. Please provide a primary (using -p)." +
+				" Run the command: tendermint light --help for more information")
+		}
+	} else {
+		err := saveProviders(db, primaryAddr, witnessAddrsJoined)
+		if err != nil {
+			logger.Error("Unable to save primary and or witness addresses", "err", err)
+		}
+	}
+
+	trustLevel, err := tmmath.ParseFraction(trustLevelStr)
+	if err != nil {
+		return fmt.Errorf("can't parse trust level: %w", err)
+	}
+
+	options := []light.Option{light.Logger(logger)}
+
+	if sequential {
+		options = append(options, light.SequentialVerification())
+	} else {
+		options = append(options, light.SkippingVerification(trustLevel))
+	}
+
+	// Initiate the light client. If the trusted store already has blocks in it, this
+	// will be used else we use the trusted options.
+	c, err := light.NewHTTPClient(
+		context.Background(),
+		chainID,
+		light.TrustOptions{
+			Period: trustingPeriod,
+			Height: trustedHeight,
+			Hash:   trustedHash,
+		},
+		primaryAddr,
+		witnessesAddrs,
+		dbs.New(db),
+		options...,
+	)
+	if err != nil {
+		return err
+	}
+
+	cfg := rpcserver.DefaultConfig()
+	cfg.MaxBodyBytes = config.RPC.MaxBodyBytes
+	cfg.MaxHeaderBytes = config.RPC.MaxHeaderBytes
+	cfg.MaxOpenConnections = maxOpenConnections
+	// If necessary adjust global WriteTimeout to ensure it's greater than
+	// TimeoutBroadcastTxCommit.
+	// See https://github.com/tendermint/tendermint/issues/3435
+	if cfg.WriteTimeout <= config.RPC.TimeoutBroadcastTxCommit {
+		cfg.WriteTimeout = config.RPC.TimeoutBroadcastTxCommit + 1*time.Second
+	}
+
+	p, err := lproxy.NewProxy(c, listenAddr, primaryAddr, cfg, logger, lrpc.KeyPathFn(lrpc.DefaultMerkleKeyPathFn()))
+	if err != nil {
+		return err
+	}
+
+	// Stop upon receiving SIGTERM or CTRL-C.
+	tmos.TrapSignal(cmd.Context(), logger, func() {
+		p.Listener.Close()
+	})
+
+	// this might be redundant to the above, eventually.
+	ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM)
+	defer cancel()
+
+	logger.Info("Starting proxy...", "laddr", listenAddr)
+	if err := p.ListenAndServe(ctx); err != http.ErrServerClosed {
+		// Error starting or closing listener:
+		logger.Error("proxy ListenAndServe", "err", err)
+	}
+
+	return nil
+}
+
+func checkForExistingProviders(db dbm.DB) (string, []string, error) {
+	primaryBytes, err := db.Get(primaryKey)
+	if err != nil {
+		return "", []string{""}, err
+	}
+	witnessesBytes, err := db.Get(witnessesKey)
+	if err != nil {
+		return "", []string{""}, err
+	}
+	witnessesAddrs := strings.Split(string(witnessesBytes), ",")
+	return string(primaryBytes), witnessesAddrs, nil
+}
+
+func saveProviders(db dbm.DB, primaryAddr, witnessesAddrs string) error {
+	err := db.Set(primaryKey, []byte(primaryAddr))
+	if err != nil {
+		return fmt.Errorf("failed to save primary provider: %w", err)
+	}
+	err = db.Set(witnessesKey, []byte(witnessesAddrs))
+	if err != nil {
+		return fmt.Errorf("failed to save witness providers: %w", err)
+	}
+	return nil
 }
--- a/cmd/tendermint/commands/reindex_event.go
+++ b/cmd/tendermint/commands/reindex_event.go
@@ -17,7 +17,6 @@ import (
 	"github.com/tendermint/tendermint/internal/state/indexer/sink/kv"
 	"github.com/tendermint/tendermint/internal/state/indexer/sink/psql"
 	"github.com/tendermint/tendermint/internal/store"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/rpc/coretypes"
 	"github.com/tendermint/tendermint/types"
@@ -27,68 +26,59 @@ const (
 	reindexFailed = "event re-index failed: "
 )

-// MakeReindexEventCommand constructs a command to re-index events in a block height interval.
-func MakeReindexEventCommand(conf *tmcfg.Config, logger log.Logger) *cobra.Command {
-	var (
-		startHeight int64
-		endHeight   int64
-	)
-
-	cmd := &cobra.Command{
-		Use:   "reindex-event",
-		Short: "reindex events to the event store backends",
-		Long: `
+// ReIndexEventCmd allows re-index the event by given block height interval
+var ReIndexEventCmd = &cobra.Command{
+	Use:   "reindex-event",
+	Short: "reindex events to the event store backends",
+	Long: `
 reindex-event is an offline tooling to re-index block and tx events to the eventsinks,
-you can run this command when the event store backend dropped/disconnected or you want to
-replace the backend. The default start-height is 0, meaning the tooling will start
-reindex from the base block height(inclusive); and the default end-height is 0, meaning
+you can run this command when the event store backend dropped/disconnected or you want to 
+replace the backend. The default start-height is 0, meaning the tooling will start 
+reindex from the base block height(inclusive); and the default end-height is 0, meaning 
 the tooling will reindex until the latest block height(inclusive). User can omit
 either or both arguments.
 	`,
-		Example: `
+	Example: `
 	tendermint reindex-event
 	tendermint reindex-event --start-height 2
 	tendermint reindex-event --end-height 10
 	tendermint reindex-event --start-height 2 --end-height 10
 	`,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			bs, ss, err := loadStateAndBlockStore(conf)
-			if err != nil {
-				return fmt.Errorf("%s: %w", reindexFailed, err)
-			}
+	Run: func(cmd *cobra.Command, args []string) {
+		bs, ss, err := loadStateAndBlockStore(config)
+		if err != nil {
+			fmt.Println(reindexFailed, err)
+			return
+		}

-			cvhArgs := checkValidHeightArgs{
-				startHeight: startHeight,
-				endHeight:   endHeight,
-			}
-			if err := checkValidHeight(bs, cvhArgs); err != nil {
-				return fmt.Errorf("%s: %w", reindexFailed, err)
-			}
+		if err := checkValidHeight(bs); err != nil {
+			fmt.Println(reindexFailed, err)
+			return
+		}

-			es, err := loadEventSinks(conf)
-			if err != nil {
-				return fmt.Errorf("%s: %w", reindexFailed, err)
-			}
+		es, err := loadEventSinks(config)
+		if err != nil {
+			fmt.Println(reindexFailed, err)
+			return
+		}

-			riArgs := eventReIndexArgs{
-				startHeight: startHeight,
-				endHeight:   endHeight,
-				sinks:       es,
-				blockStore:  bs,
-				stateStore:  ss,
-			}
-			if err := eventReIndex(cmd, riArgs); err != nil {
-				return fmt.Errorf("%s: %w", reindexFailed, err)
-			}
+		if err = eventReIndex(cmd, es, bs, ss); err != nil {
+			fmt.Println(reindexFailed, err)
+			return
+		}

-			logger.Info("event re-index finished")
-			return nil
-		},
-	}
+		fmt.Println("event re-index finished")
+	},
+}

-	cmd.Flags().Int64Var(&startHeight, "start-height", 0, "the block height would like to start for re-index")
-	cmd.Flags().Int64Var(&endHeight, "end-height", 0, "the block height would like to finish for re-index")
-	return cmd
+var (
+	startHeight int64
+	endHeight   int64
+)
+
+func init() {
+	ReIndexEventCmd.Flags().Int64Var(&startHeight, "start-height", 0, "the block height would like to start for re-index")
+	ReIndexEventCmd.Flags().Int64Var(&endHeight, "end-height", 0, "the block height would like to finish for re-index")
 }

 func loadEventSinks(cfg *tmcfg.Config) ([]indexer.EventSink, error) {
@@ -119,7 +109,7 @@ func loadEventSinks(cfg *tmcfg.Config) ([]indexer.EventSink, error) {
 			if conn == "" {
 				return nil, errors.New("the psql connection settings cannot be empty")
 			}
-			es, err := psql.NewEventSink(conn, cfg.ChainID())
+			es, err := psql.NewEventSink(conn, chainID)
 			if err != nil {
 				return nil, err
 			}
@@ -169,58 +159,52 @@ func loadStateAndBlockStore(cfg *tmcfg.Config) (*store.BlockStore, state.Store,
 	return blockStore, stateStore, nil
 }

-type eventReIndexArgs struct {
-	startHeight int64
-	endHeight   int64
-	sinks       []indexer.EventSink
-	blockStore  state.BlockStore
-	stateStore  state.Store
-}
+func eventReIndex(cmd *cobra.Command, es []indexer.EventSink, bs state.BlockStore, ss state.Store) error {

-func eventReIndex(cmd *cobra.Command, args eventReIndexArgs) error {
 	var bar progressbar.Bar
-	bar.NewOption(args.startHeight-1, args.endHeight)
+	bar.NewOption(startHeight-1, endHeight)

 	fmt.Println("start re-indexing events:")
 	defer bar.Finish()
-	for i := args.startHeight; i <= args.endHeight; i++ {
+	for i := startHeight; i <= endHeight; i++ {
 		select {
 		case <-cmd.Context().Done():
 			return fmt.Errorf("event re-index terminated at height %d: %w", i, cmd.Context().Err())
 		default:
-			b := args.blockStore.LoadBlock(i)
+			b := bs.LoadBlock(i)
 			if b == nil {
 				return fmt.Errorf("not able to load block at height %d from the blockstore", i)
 			}

-			r, err := args.stateStore.LoadABCIResponses(i)
+			r, err := ss.LoadABCIResponses(i)
 			if err != nil {
 				return fmt.Errorf("not able to load ABCI Response at height %d from the statestore", i)
 			}

 			e := types.EventDataNewBlockHeader{
-				Header:              b.Header,
-				NumTxs:              int64(len(b.Txs)),
-				ResultFinalizeBlock: *r.FinalizeBlock,
+				Header:           b.Header,
+				NumTxs:           int64(len(b.Txs)),
+				ResultBeginBlock: *r.BeginBlock,
+				ResultEndBlock:   *r.EndBlock,
 			}

 			var batch *indexer.Batch
 			if e.NumTxs > 0 {
 				batch = indexer.NewBatch(e.NumTxs)

-				for i := range b.Data.Txs {
+				for i, tx := range b.Data.Txs {
 					tr := abcitypes.TxResult{
 						Height: b.Height,
 						Index:  uint32(i),
-						Tx:     b.Data.Txs[i],
-						Result: *(r.FinalizeBlock.Txs[i]),
+						Tx:     tx,
+						Result: *(r.DeliverTxs[i]),
 					}

 					_ = batch.Add(&tr)
 				}
 			}

-			for _, sink := range args.sinks {
+			for _, sink := range es {
 				if err := sink.IndexBlockEvents(e); err != nil {
 					return fmt.Errorf("block event re-index at height %d failed: %w", i, err)
 				}
@@ -239,45 +223,40 @@ func eventReIndex(cmd *cobra.Command, args eventReIndexArgs) error {
 	return nil
 }

-type checkValidHeightArgs struct {
-	startHeight int64
-	endHeight   int64
-}
-
-func checkValidHeight(bs state.BlockStore, args checkValidHeightArgs) error {
+func checkValidHeight(bs state.BlockStore) error {
 	base := bs.Base()

-	if args.startHeight == 0 {
-		args.startHeight = base
+	if startHeight == 0 {
+		startHeight = base
 		fmt.Printf("set the start block height to the base height of the blockstore %d \n", base)
 	}

-	if args.startHeight < base {
+	if startHeight < base {
 		return fmt.Errorf("%s (requested start height: %d, base height: %d)",
-			coretypes.ErrHeightNotAvailable, args.startHeight, base)
+			coretypes.ErrHeightNotAvailable, startHeight, base)
 	}

 	height := bs.Height()

-	if args.startHeight > height {
+	if startHeight > height {
 		return fmt.Errorf(
-			"%s (requested start height: %d, store height: %d)", coretypes.ErrHeightNotAvailable, args.startHeight, height)
+			"%s (requested start height: %d, store height: %d)", coretypes.ErrHeightNotAvailable, startHeight, height)
 	}

-	if args.endHeight == 0 || args.endHeight > height {
-		args.endHeight = height
+	if endHeight == 0 || endHeight > height {
+		endHeight = height
 		fmt.Printf("set the end block height to the latest height of the blockstore %d \n", height)
 	}

-	if args.endHeight < base {
+	if endHeight < base {
 		return fmt.Errorf(
-			"%s (requested end height: %d, base height: %d)", coretypes.ErrHeightNotAvailable, args.endHeight, base)
+			"%s (requested end height: %d, base height: %d)", coretypes.ErrHeightNotAvailable, endHeight, base)
 	}

-	if args.endHeight < args.startHeight {
+	if endHeight < startHeight {
 		return fmt.Errorf(
 			"%s (requested the end height: %d is less than the start height: %d)",
-			coretypes.ErrInvalidRequest, args.startHeight, args.endHeight)
+			coretypes.ErrInvalidRequest, startHeight, endHeight)
 	}

 	return nil
--- a/cmd/tendermint/commands/reindex_event_test.go
+++ b/cmd/tendermint/commands/reindex_event_test.go
@@ -9,15 +9,13 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"

-	dbm "github.com/tendermint/tm-db"
-
 	abcitypes "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/config"
+	tmcfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/state/indexer"
 	"github.com/tendermint/tendermint/internal/state/mocks"
-	"github.com/tendermint/tendermint/libs/log"
 	prototmstate "github.com/tendermint/tendermint/proto/tendermint/state"
 	"github.com/tendermint/tendermint/types"
+	dbm "github.com/tendermint/tm-db"

 	_ "github.com/lib/pq" // for the psql sink
 )
@@ -27,15 +25,13 @@ const (
 	base   int64 = 2
 )

-func setupReIndexEventCmd(ctx context.Context, conf *config.Config, logger log.Logger) *cobra.Command {
-	cmd := MakeReindexEventCommand(conf, logger)
-
+func setupReIndexEventCmd() *cobra.Command {
 	reIndexEventCmd := &cobra.Command{
-		Use: cmd.Use,
+		Use: ReIndexEventCmd.Use,
 		Run: func(cmd *cobra.Command, args []string) {},
 	}

-	_ = reIndexEventCmd.ExecuteContext(ctx)
+	_ = reIndexEventCmd.ExecuteContext(context.Background())

 	return reIndexEventCmd
 }
@@ -72,7 +68,10 @@ func TestReIndexEventCheckHeight(t *testing.T) {
 	}

 	for _, tc := range testCases {
-		err := checkValidHeight(mockBlockStore, checkValidHeightArgs{startHeight: tc.startHeight, endHeight: tc.endHeight})
+		startHeight = tc.startHeight
+		endHeight = tc.endHeight
+
+		err := checkValidHeight(mockBlockStore)
 		if tc.validHeight {
 			require.NoError(t, err)
 		} else {
@@ -98,7 +97,7 @@ func TestLoadEventSink(t *testing.T) {
 	}

 	for _, tc := range testCases {
-		cfg := config.TestConfig()
+		cfg := tmcfg.TestConfig()
 		cfg.TxIndex.Indexer = tc.sinks
 		cfg.TxIndex.PsqlConn = tc.connURL
 		_, err := loadEventSinks(cfg)
@@ -111,7 +110,7 @@ func TestLoadEventSink(t *testing.T) {
 }

 func TestLoadBlockStore(t *testing.T) {
-	testCfg, err := config.ResetTestRoot(t.TempDir(), t.Name())
+	testCfg, err := tmcfg.ResetTestRoot(t.Name())
 	require.NoError(t, err)
 	testCfg.DBBackend = "goleveldb"
 	_, _, err = loadStateAndBlockStore(testCfg)
@@ -155,9 +154,9 @@ func TestReIndexEvent(t *testing.T) {

 	dtx := abcitypes.ResponseDeliverTx{}
 	abciResp := &prototmstate.ABCIResponses{
-		FinalizeBlock: &abcitypes.ResponseFinalizeBlock{
-			Txs: []*abcitypes.ResponseDeliverTx{&dtx},
-		},
+		DeliverTxs: []*abcitypes.ResponseDeliverTx{&dtx},
+		EndBlock:   &abcitypes.ResponseEndBlock{},
+		BeginBlock: &abcitypes.ResponseBeginBlock{},
 	}

 	mockStateStore.
@@ -178,22 +177,11 @@ func TestReIndexEvent(t *testing.T) {
 		{height, height, false},
 	}

-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	logger := log.NewNopLogger()
-	conf := config.DefaultConfig()
-
 	for _, tc := range testCases {
-		err := eventReIndex(
-			setupReIndexEventCmd(ctx, conf, logger),
-			eventReIndexArgs{
-				sinks:       []indexer.EventSink{mockEventSink},
-				blockStore:  mockBlockStore,
-				stateStore:  mockStateStore,
-				startHeight: tc.startHeight,
-				endHeight:   tc.endHeight,
-			})
+		startHeight = tc.startHeight
+		endHeight = tc.endHeight

+		err := eventReIndex(setupReIndexEventCmd(), []indexer.EventSink{mockEventSink}, mockBlockStore, mockStateStore)
 		if tc.reIndexErr {
 			require.Error(t, err)
 		} else {
--- a/cmd/tendermint/commands/replay.go
+++ b/cmd/tendermint/commands/replay.go
@@ -2,30 +2,24 @@ package commands

 import (
 	"github.com/spf13/cobra"
-
-	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/consensus"
-	"github.com/tendermint/tendermint/libs/log"
 )

-// MakeReplayCommand constructs a command to replay messages from the WAL into consensus.
-func MakeReplayCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	return &cobra.Command{
-		Use:   "replay",
-		Short: "Replay messages from WAL",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return consensus.RunReplayFile(cmd.Context(), logger, conf.BaseConfig, conf.Consensus, false)
-		},
-	}
+// ReplayCmd allows replaying of messages from the WAL.
+var ReplayCmd = &cobra.Command{
+	Use:   "replay",
+	Short: "Replay messages from WAL",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return consensus.RunReplayFile(cmd.Context(), logger, config.BaseConfig, config.Consensus, false)
+	},
 }

-// MakeReplayConsoleCommand constructs a command to replay WAL messages to stdout.
-func MakeReplayConsoleCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	return &cobra.Command{
-		Use:   "replay-console",
-		Short: "Replay messages from WAL in a console",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return consensus.RunReplayFile(cmd.Context(), logger, conf.BaseConfig, conf.Consensus, true)
-		},
-	}
+// ReplayConsoleCmd allows replaying of messages from the WAL in a
+// console.
+var ReplayConsoleCmd = &cobra.Command{
+	Use:   "replay-console",
+	Short: "Replay messages from WAL in a console",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return consensus.RunReplayFile(cmd.Context(), logger, config.BaseConfig, config.Consensus, true)
+	},
 }
--- a/cmd/tendermint/commands/reset_priv_validator.go
+++ b/cmd/tendermint/commands/reset_priv_validator.go
@@ -5,79 +5,70 @@ import (

 	"github.com/spf13/cobra"

-	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	tmos "github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/privval"
 	"github.com/tendermint/tendermint/types"
 )

-// MakeResetAllCommand constructs a command that removes the database of
-// the specified Tendermint core instance.
-func MakeResetAllCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	var keyType string
-
-	cmd := &cobra.Command{
-		Use:   "unsafe-reset-all",
-		Short: "(unsafe) Remove all the data and WAL, reset this node's validator to genesis state",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return resetAll(conf.DBDir(), conf.PrivValidator.KeyFile(),
-				conf.PrivValidator.StateFile(), logger, keyType)
-		},
-	}
-	cmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
-		"Key type to generate privval file with. Options: ed25519, secp256k1")
-
-	return cmd
+// ResetAllCmd removes the database of this Tendermint core
+// instance.
+var ResetAllCmd = &cobra.Command{
+	Use:   "unsafe-reset-all",
+	Short: "(unsafe) Remove all the data and WAL, reset this node's validator to genesis state",
+	RunE:  resetAll,
 }

-func MakeResetPrivateValidatorCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	var keyType string
+var keepAddrBook bool

-	cmd := &cobra.Command{
-		Use:   "unsafe-reset-priv-validator",
-		Short: "(unsafe) Reset this node's validator to genesis state",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return resetFilePV(conf.PrivValidator.KeyFile(), conf.PrivValidator.StateFile(), logger, keyType)
-		},
-	}
-
-	cmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
+func init() {
+	ResetAllCmd.Flags().BoolVar(&keepAddrBook, "keep-addr-book", false, "keep the address book intact")
+	ResetPrivValidatorCmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
 		"Key type to generate privval file with. Options: ed25519, secp256k1")
-	return cmd
+}

+// ResetPrivValidatorCmd resets the private validator files.
+var ResetPrivValidatorCmd = &cobra.Command{
+	Use:   "unsafe-reset-priv-validator",
+	Short: "(unsafe) Reset this node's validator to genesis state",
+	RunE:  resetPrivValidator,
 }

 // XXX: this is totally unsafe.
 // it's only suitable for testnets.
+func resetAll(cmd *cobra.Command, args []string) error {
+	return ResetAll(config.DBDir(), config.PrivValidator.KeyFile(),
+		config.PrivValidator.StateFile(), logger)
+}

 // XXX: this is totally unsafe.
 // it's only suitable for testnets.
+func resetPrivValidator(cmd *cobra.Command, args []string) error {
+	return resetFilePV(config.PrivValidator.KeyFile(), config.PrivValidator.StateFile(), logger)
+}

-// resetAll removes address book files plus all data, and resets the privValdiator data.
+// ResetAll removes address book files plus all data, and resets the privValdiator data.
 // Exported so other CLI tools can use it.
-func resetAll(dbDir, privValKeyFile, privValStateFile string, logger log.Logger, keyType string) error {
+func ResetAll(dbDir, privValKeyFile, privValStateFile string, logger log.Logger) error {
 	if err := os.RemoveAll(dbDir); err == nil {
 		logger.Info("Removed all blockchain history", "dir", dbDir)
 	} else {
-		logger.Error("error removing all blockchain history", "dir", dbDir, "err", err)
+		logger.Error("Error removing all blockchain history", "dir", dbDir, "err", err)
 	}
 	// recreate the dbDir since the privVal state needs to live there
 	if err := tmos.EnsureDir(dbDir, 0700); err != nil {
 		logger.Error("unable to recreate dbDir", "err", err)
 	}
-	return resetFilePV(privValKeyFile, privValStateFile, logger, keyType)
+	return resetFilePV(privValKeyFile, privValStateFile, logger)
 }

-func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger, keyType string) error {
+func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger) error {
 	if _, err := os.Stat(privValKeyFile); err == nil {
 		pv, err := privval.LoadFilePVEmptyState(privValKeyFile, privValStateFile)
 		if err != nil {
 			return err
 		}
-		if err := pv.Reset(); err != nil {
-			return err
-		}
+		pv.Reset()
 		logger.Info("Reset private validator file to genesis state", "keyFile", privValKeyFile,
 			"stateFile", privValStateFile)
 	} else {
@@ -85,9 +76,7 @@ func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger, key
 		if err != nil {
 			return err
 		}
-		if err := pv.Save(); err != nil {
-			return err
-		}
+		pv.Save()
 		logger.Info("Generated private validator file", "keyFile", privValKeyFile,
 			"stateFile", privValStateFile)
 	}
--- a/cmd/tendermint/commands/rollback.go
+++ b/cmd/tendermint/commands/rollback.go
@@ -5,15 +5,14 @@ import (

 	"github.com/spf13/cobra"

-	"github.com/tendermint/tendermint/config"
+	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/state"
 )

-func MakeRollbackStateCommand(conf *config.Config) *cobra.Command {
-	return &cobra.Command{
-		Use:   "rollback",
-		Short: "rollback tendermint state by one height",
-		Long: `
+var RollbackStateCmd = &cobra.Command{
+	Use:   "rollback",
+	Short: "rollback tendermint state by one height",
+	Long: `
 A state rollback is performed to recover from an incorrect application state transition,
 when Tendermint has persisted an incorrect app hash and is thus unable to make
 progress. Rollback overwrites a state at height n with the state at height n - 1.
@@ -21,23 +20,21 @@ The application should also roll back to height n - 1. No blocks are removed, so
 restarting Tendermint the transactions in block n will be re-executed against the
 application.
 `,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			height, hash, err := RollbackState(conf)
-			if err != nil {
-				return fmt.Errorf("failed to rollback state: %w", err)
-			}
-
-			fmt.Printf("Rolled back state to height %d and hash %X", height, hash)
-			return nil
-		},
-	}
+	RunE: func(cmd *cobra.Command, args []string) error {
+		height, hash, err := RollbackState(config)
+		if err != nil {
+			return fmt.Errorf("failed to rollback state: %w", err)
+		}

+		fmt.Printf("Rolled back state to height %d and hash %X", height, hash)
+		return nil
+	},
 }

 // RollbackState takes the state at the current height n and overwrites it with the state
 // at height n - 1. Note state here refers to tendermint state not application state.
 // Returns the latest state height and app hash alongside an error if there was one.
-func RollbackState(config *config.Config) (int64, []byte, error) {
+func RollbackState(config *cfg.Config) (int64, []byte, error) {
 	// use the parsed config to load the block and state store
 	blockStore, stateStore, err := loadStateAndBlockStore(config)
 	if err != nil {
--- a/cmd/tendermint/commands/rollback_test.go
+++ b/cmd/tendermint/commands/rollback_test.go
@@ -8,7 +8,6 @@ import (
 	"github.com/stretchr/testify/require"

 	"github.com/tendermint/tendermint/cmd/tendermint/commands"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/rpc/client/local"
 	rpctest "github.com/tendermint/tendermint/rpc/test"
 	e2e "github.com/tendermint/tendermint/test/e2e/app"
@@ -19,12 +18,10 @@ func TestRollbackIntegration(t *testing.T) {
 	dir := t.TempDir()
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	cfg, err := rpctest.CreateConfig(t, t.Name())
+	cfg, err := rpctest.CreateConfig(t.Name())
 	require.NoError(t, err)
 	cfg.BaseConfig.DBBackend = "goleveldb"
-
 	app, err := e2e.NewApplication(e2e.DefaultConfig(dir))
-	require.NoError(t, err)

 	t.Run("First run", func(t *testing.T) {
 		ctx, cancel := context.WithCancel(ctx)
@@ -32,31 +29,27 @@ func TestRollbackIntegration(t *testing.T) {
 		require.NoError(t, err)
 		node, _, err := rpctest.StartTendermint(ctx, cfg, app, rpctest.SuppressStdout)
 		require.NoError(t, err)
-		require.True(t, node.IsRunning())

 		time.Sleep(3 * time.Second)
 		cancel()
 		node.Wait()
-
 		require.False(t, node.IsRunning())
 	})
+
 	t.Run("Rollback", func(t *testing.T) {
-		time.Sleep(time.Second)
 		require.NoError(t, app.Rollback())
 		height, _, err = commands.RollbackState(cfg)
-		require.NoError(t, err, "%d", height)
-	})
-	t.Run("Restart", func(t *testing.T) {
-		require.True(t, height > 0, "%d", height)
+		require.NoError(t, err)

+	})
+
+	t.Run("Restart", func(t *testing.T) {
 		ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 		defer cancel()
 		node2, _, err2 := rpctest.StartTendermint(ctx, cfg, app, rpctest.SuppressStdout)
 		require.NoError(t, err2)

-		logger := log.NewNopLogger()
-
-		client, err := local.New(logger, node2.(local.NodeService))
+		client, err := local.New(node2.(local.NodeService))
 		require.NoError(t, err)

 		ticker := time.NewTicker(200 * time.Millisecond)
--- a/cmd/tendermint/commands/root.go
+++ b/cmd/tendermint/commands/root.go
@@ -2,62 +2,65 @@ package commands

 import (
 	"fmt"
-	"os"
-	"path/filepath"
 	"time"

 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"

-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/libs/cli"
+	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 )

-const ctxTimeout = 4 * time.Second
+var (
+	config     = cfg.DefaultConfig()
+	logger     = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
+	ctxTimeout = 4 * time.Second
+)
+
+func init() {
+	registerFlagsRootCmd(RootCmd)
+}
+
+func registerFlagsRootCmd(cmd *cobra.Command) {
+	cmd.PersistentFlags().String("log-level", config.LogLevel, "log level")
+}

 // ParseConfig retrieves the default environment configuration,
 // sets up the Tendermint root and ensures that the root exists
-func ParseConfig(conf *config.Config) (*config.Config, error) {
-	if err := viper.Unmarshal(conf); err != nil {
+func ParseConfig() (*cfg.Config, error) {
+	conf := cfg.DefaultConfig()
+	err := viper.Unmarshal(conf)
+	if err != nil {
 		return nil, err
 	}
-
 	conf.SetRoot(conf.RootDir)
-
+	cfg.EnsureRoot(conf.RootDir)
 	if err := conf.ValidateBasic(); err != nil {
-		return nil, fmt.Errorf("error in config file: %w", err)
+		return nil, fmt.Errorf("error in config file: %v", err)
 	}
 	return conf, nil
 }

-// RootCommand constructs the root command-line entry point for Tendermint core.
-func RootCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "tendermint",
-		Short: "BFT state machine replication for applications in any programming languages",
-		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
-			if cmd.Name() == VersionCmd.Name() {
-				return nil
-			}
-
-			if err := cli.BindFlagsLoadViper(cmd, args); err != nil {
-				return err
-			}
-
-			pconf, err := ParseConfig(conf)
-			if err != nil {
-				return err
-			}
-			*conf = *pconf
-			config.EnsureRoot(conf.RootDir)
-
+// RootCmd is the root command for Tendermint core.
+var RootCmd = &cobra.Command{
+	Use:   "tendermint",
+	Short: "BFT state machine replication for applications in any programming languages",
+	PersistentPreRunE: func(cmd *cobra.Command, args []string) (err error) {
+		if cmd.Name() == VersionCmd.Name() {
 			return nil
-		},
-	}
-	cmd.PersistentFlags().StringP(cli.HomeFlag, "", os.ExpandEnv(filepath.Join("$HOME", config.DefaultTendermintDir)), "directory for config and data")
-	cmd.PersistentFlags().Bool(cli.TraceFlag, false, "print out full stack trace on errors")
-	cmd.PersistentFlags().String("log-level", conf.LogLevel, "log level")
-	cobra.OnInitialize(func() { cli.InitEnv("TM") })
-	return cmd
+		}
+
+		config, err = ParseConfig()
+		if err != nil {
+			return err
+		}
+
+		logger, err = log.NewDefaultLogger(config.LogFormat, config.LogLevel, false)
+		if err != nil {
+			return err
+		}
+
+		logger = logger.With("module", "main")
+		return nil
+	},
 }
--- a/cmd/tendermint/commands/root_test.go
+++ b/cmd/tendermint/commands/root_test.go
@@ -1,10 +1,10 @@
 package commands

 import (
-	"context"
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
 	"testing"

 	"github.com/spf13/cobra"
@@ -14,54 +14,47 @@ import (

 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/cli"
-	"github.com/tendermint/tendermint/libs/log"
 	tmos "github.com/tendermint/tendermint/libs/os"
 )

-// writeConfigVals writes a toml file with the given values.
-// It returns an error if writing was impossible.
-func writeConfigVals(dir string, vals map[string]string) error {
-	data := ""
-	for k, v := range vals {
-		data += fmt.Sprintf("%s = \"%s\"\n", k, v)
-	}
-	cfile := filepath.Join(dir, "config.toml")
-	return os.WriteFile(cfile, []byte(data), 0600)
-}
-
 // clearConfig clears env vars, the given root dir, and resets viper.
-func clearConfig(t *testing.T, dir string) *cfg.Config {
-	t.Helper()
-	require.NoError(t, os.Unsetenv("TMHOME"))
-	require.NoError(t, os.Unsetenv("TM_HOME"))
-	require.NoError(t, os.RemoveAll(dir))
+func clearConfig(dir string) {
+	if err := os.Unsetenv("TMHOME"); err != nil {
+		panic(err)
+	}
+	if err := os.Unsetenv("TM_HOME"); err != nil {
+		panic(err)
+	}

+	if err := os.RemoveAll(dir); err != nil {
+		panic(err)
+	}
 	viper.Reset()
-	conf := cfg.DefaultConfig()
-	conf.RootDir = dir
-	return conf
+	config = cfg.DefaultConfig()
 }

 // prepare new rootCmd
-func testRootCmd(conf *cfg.Config) *cobra.Command {
-	logger := log.NewNopLogger()
-	cmd := RootCommand(conf, logger)
-	cmd.RunE = func(cmd *cobra.Command, args []string) error { return nil }
-
+func testRootCmd() *cobra.Command {
+	rootCmd := &cobra.Command{
+		Use:               RootCmd.Use,
+		PersistentPreRunE: RootCmd.PersistentPreRunE,
+		Run:               func(cmd *cobra.Command, args []string) {},
+	}
+	registerFlagsRootCmd(rootCmd)
 	var l string
-	cmd.PersistentFlags().String("log", l, "Log")
-	return cmd
+	rootCmd.PersistentFlags().String("log", l, "Log")
+	return rootCmd
 }

-func testSetup(ctx context.Context, t *testing.T, conf *cfg.Config, args []string, env map[string]string) error {
-	t.Helper()
+func testSetup(rootDir string, args []string, env map[string]string) error {
+	clearConfig(rootDir)

-	cmd := testRootCmd(conf)
-	viper.Set(cli.HomeFlag, conf.RootDir)
+	rootCmd := testRootCmd()
+	cmd := cli.PrepareBaseCmd(rootCmd, "TM", rootDir)

 	// run with the args and env
-	args = append([]string{cmd.Use}, args...)
-	return cli.RunWithArgs(ctx, cmd, args, env)
+	args = append([]string{rootCmd.Use}, args...)
+	return cli.RunWithArgs(cmd, args, env)
 }

 func TestRootHome(t *testing.T) {
@@ -77,29 +70,23 @@ func TestRootHome(t *testing.T) {
 		{nil, map[string]string{"TMHOME": newRoot}, newRoot},
 	}

-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	for i, tc := range cases {
-		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			conf := clearConfig(t, tc.root)
+		idxString := strconv.Itoa(i)

-			err := testSetup(ctx, t, conf, tc.args, tc.env)
-			require.NoError(t, err)
+		err := testSetup(defaultRoot, tc.args, tc.env)
+		require.Nil(t, err, idxString)

-			require.Equal(t, tc.root, conf.RootDir)
-			require.Equal(t, tc.root, conf.P2P.RootDir)
-			require.Equal(t, tc.root, conf.Consensus.RootDir)
-			require.Equal(t, tc.root, conf.Mempool.RootDir)
-		})
+		assert.Equal(t, tc.root, config.RootDir, idxString)
+		assert.Equal(t, tc.root, config.P2P.RootDir, idxString)
+		assert.Equal(t, tc.root, config.Consensus.RootDir, idxString)
+		assert.Equal(t, tc.root, config.Mempool.RootDir, idxString)
 	}
 }

 func TestRootFlagsEnv(t *testing.T) {
+
 	// defaults
 	defaults := cfg.DefaultConfig()
-	defaultDir := t.TempDir()
-
 	defaultLogLvl := defaults.LogLevel

 	cases := []struct {
@@ -114,25 +101,18 @@ func TestRootFlagsEnv(t *testing.T) {
 		{nil, map[string]string{"TM_LOG_LEVEL": "debug"}, "debug"},       // right env
 	}

-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
+	defaultRoot := t.TempDir()
 	for i, tc := range cases {
-		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			conf := clearConfig(t, defaultDir)
+		idxString := strconv.Itoa(i)

-			err := testSetup(ctx, t, conf, tc.args, tc.env)
-			require.NoError(t, err)
-
-			assert.Equal(t, tc.logLevel, conf.LogLevel)
-		})
+		err := testSetup(defaultRoot, tc.args, tc.env)
+		require.Nil(t, err, idxString)

+		assert.Equal(t, tc.logLevel, config.LogLevel, idxString)
 	}
 }

 func TestRootConfig(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()

 	// write non-default config
 	nonDefaultLogLvl := "debug"
@@ -141,8 +121,9 @@ func TestRootConfig(t *testing.T) {
 	}

 	cases := []struct {
-		args   []string
-		env    map[string]string
+		args []string
+		env  map[string]string
+
 		logLvl string
 	}{
 		{nil, nil, nonDefaultLogLvl},                             // should load config
@@ -151,30 +132,29 @@ func TestRootConfig(t *testing.T) {
 	}

 	for i, tc := range cases {
-		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			defaultRoot := t.TempDir()
-			conf := clearConfig(t, defaultRoot)
-			conf.LogLevel = tc.logLvl
+		defaultRoot := t.TempDir()
+		idxString := strconv.Itoa(i)
+		clearConfig(defaultRoot)

-			// XXX: path must match cfg.defaultConfigPath
-			configFilePath := filepath.Join(defaultRoot, "config")
-			err := tmos.EnsureDir(configFilePath, 0700)
-			require.NoError(t, err)
+		// XXX: path must match cfg.defaultConfigPath
+		configFilePath := filepath.Join(defaultRoot, "config")
+		err := tmos.EnsureDir(configFilePath, 0700)
+		require.Nil(t, err)

-			// write the non-defaults to a different path
-			// TODO: support writing sub configs so we can test that too
-			err = writeConfigVals(configFilePath, cvals)
-			require.NoError(t, err)
+		// write the non-defaults to a different path
+		// TODO: support writing sub configs so we can test that too
+		err = WriteConfigVals(configFilePath, cvals)
+		require.Nil(t, err)

-			cmd := testRootCmd(conf)
+		rootCmd := testRootCmd()
+		cmd := cli.PrepareBaseCmd(rootCmd, "TM", defaultRoot)

-			// run with the args and env
-			tc.args = append([]string{cmd.Use}, tc.args...)
-			err = cli.RunWithArgs(ctx, cmd, tc.args, tc.env)
-			require.NoError(t, err)
+		// run with the args and env
+		tc.args = append([]string{rootCmd.Use}, tc.args...)
+		err = cli.RunWithArgs(cmd, tc.args, tc.env)
+		require.Nil(t, err, idxString)

-			require.Equal(t, tc.logLvl, conf.LogLevel)
-		})
+		assert.Equal(t, tc.logLvl, config.LogLevel, idxString)
 	}
 }

--- a/cmd/tendermint/commands/run_node.go
+++ b/cmd/tendermint/commands/run_node.go
@@ -12,26 +12,25 @@ import (
 	"github.com/spf13/cobra"

 	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/libs/log"
 )

 var (
 	genesisHash []byte
 )

-// AddNodeFlags exposes some common configuration options from conf in the flag
-// set for cmd. This is a convenience for commands embedding a Tendermint node.
-func AddNodeFlags(cmd *cobra.Command, conf *cfg.Config) {
+// AddNodeFlags exposes some common configuration options on the command-line
+// These are exposed for convenience of commands embedding a tendermint node
+func AddNodeFlags(cmd *cobra.Command) {
 	// bind flags
-	cmd.Flags().String("moniker", conf.Moniker, "node name")
+	cmd.Flags().String("moniker", config.Moniker, "node name")

 	// mode flags
-	cmd.Flags().String("mode", conf.Mode, "node mode (full | validator | seed)")
+	cmd.Flags().String("mode", config.Mode, "node mode (full | validator | seed)")

 	// priv val flags
 	cmd.Flags().String(
 		"priv-validator-laddr",
-		conf.PrivValidator.ListenAddr,
+		config.PrivValidator.ListenAddr,
 		"socket address to listen on for connections from external priv-validator process")

 	// node flags
@@ -41,74 +40,74 @@ func AddNodeFlags(cmd *cobra.Command, conf *cfg.Config) {
 		"genesis-hash",
 		[]byte{},
 		"optional SHA-256 hash of the genesis file")
-	cmd.Flags().Int64("consensus.double-sign-check-height", conf.Consensus.DoubleSignCheckHeight,
+	cmd.Flags().Int64("consensus.double-sign-check-height", config.Consensus.DoubleSignCheckHeight,
 		"how many blocks to look back to check existence of the node's "+
 			"consensus votes before joining consensus")

 	// abci flags
 	cmd.Flags().String(
 		"proxy-app",
-		conf.ProxyApp,
+		config.ProxyApp,
 		"proxy app address, or one of: 'kvstore',"+
 			" 'persistent_kvstore', 'e2e' or 'noop' for local testing.")
-	cmd.Flags().String("abci", conf.ABCI, "specify abci transport (socket | grpc)")
+	cmd.Flags().String("abci", config.ABCI, "specify abci transport (socket | grpc)")

 	// rpc flags
-	cmd.Flags().String("rpc.laddr", conf.RPC.ListenAddress, "RPC listen address. Port required")
-	cmd.Flags().Bool("rpc.unsafe", conf.RPC.Unsafe, "enabled unsafe rpc methods")
-	cmd.Flags().String("rpc.pprof-laddr", conf.RPC.PprofListenAddress, "pprof listen address (https://golang.org/pkg/net/http/pprof)")
+	cmd.Flags().String("rpc.laddr", config.RPC.ListenAddress, "RPC listen address. Port required")
+	cmd.Flags().Bool("rpc.unsafe", config.RPC.Unsafe, "enabled unsafe rpc methods")
+	cmd.Flags().String("rpc.pprof-laddr", config.RPC.PprofListenAddress, "pprof listen address (https://golang.org/pkg/net/http/pprof)")

 	// p2p flags
 	cmd.Flags().String(
 		"p2p.laddr",
-		conf.P2P.ListenAddress,
+		config.P2P.ListenAddress,
 		"node listen address. (0.0.0.0:0 means any interface, any port)")
-	cmd.Flags().String("p2p.seeds", conf.P2P.Seeds, "comma-delimited ID@host:port seed nodes") //nolint: staticcheck
-	cmd.Flags().String("p2p.persistent-peers", conf.P2P.PersistentPeers, "comma-delimited ID@host:port persistent peers")
-	cmd.Flags().Bool("p2p.upnp", conf.P2P.UPNP, "enable/disable UPNP port forwarding")
-	cmd.Flags().Bool("p2p.pex", conf.P2P.PexReactor, "enable/disable Peer-Exchange")
-	cmd.Flags().String("p2p.private-peer-ids", conf.P2P.PrivatePeerIDs, "comma-delimited private peer IDs")
+	cmd.Flags().String("p2p.seeds", config.P2P.Seeds, "comma-delimited ID@host:port seed nodes")
+	cmd.Flags().String("p2p.persistent-peers", config.P2P.PersistentPeers, "comma-delimited ID@host:port persistent peers")
+	cmd.Flags().Bool("p2p.upnp", config.P2P.UPNP, "enable/disable UPNP port forwarding")
+	cmd.Flags().Bool("p2p.pex", config.P2P.PexReactor, "enable/disable Peer-Exchange")
+	cmd.Flags().String("p2p.private-peer-ids", config.P2P.PrivatePeerIDs, "comma-delimited private peer IDs")

 	// consensus flags
 	cmd.Flags().Bool(
 		"consensus.create-empty-blocks",
-		conf.Consensus.CreateEmptyBlocks,
+		config.Consensus.CreateEmptyBlocks,
 		"set this to false to only produce blocks when there are txs or when the AppHash changes")
 	cmd.Flags().String(
 		"consensus.create-empty-blocks-interval",
-		conf.Consensus.CreateEmptyBlocksInterval.String(),
+		config.Consensus.CreateEmptyBlocksInterval.String(),
 		"the possible interval between empty blocks")

-	addDBFlags(cmd, conf)
+	addDBFlags(cmd)
 }

-func addDBFlags(cmd *cobra.Command, conf *cfg.Config) {
+func addDBFlags(cmd *cobra.Command) {
 	cmd.Flags().String(
 		"db-backend",
-		conf.DBBackend,
+		config.DBBackend,
 		"database backend: goleveldb | cleveldb | boltdb | rocksdb | badgerdb")
 	cmd.Flags().String(
 		"db-dir",
-		conf.DBPath,
+		config.DBPath,
 		"database directory")
 }

 // NewRunNodeCmd returns the command that allows the CLI to start a node.
 // It can be used with a custom PrivValidator and in-process ABCI application.
-func NewRunNodeCmd(nodeProvider cfg.ServiceProvider, conf *cfg.Config, logger log.Logger) *cobra.Command {
+func NewRunNodeCmd(nodeProvider cfg.ServiceProvider) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:     "start",
 		Aliases: []string{"node", "run"},
 		Short:   "Run the tendermint node",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if err := checkGenesisHash(conf); err != nil {
+			if err := checkGenesisHash(config); err != nil {
 				return err
 			}

 			ctx, cancel := signal.NotifyContext(cmd.Context(), syscall.SIGTERM)
 			defer cancel()

-			n, err := nodeProvider(ctx, conf, logger)
+			n, err := nodeProvider(ctx, config, logger)
 			if err != nil {
 				return fmt.Errorf("failed to create node: %w", err)
 			}
@@ -117,14 +116,14 @@ func NewRunNodeCmd(nodeProvider cfg.ServiceProvider, conf *cfg.Config, logger lo
 				return fmt.Errorf("failed to start node: %w", err)
 			}

-			logger.Info("started node", "chain", conf.ChainID())
+			logger.Info("started node", "node", n.String())

 			<-ctx.Done()
 			return nil
 		},
 	}

-	AddNodeFlags(cmd, conf)
+	AddNodeFlags(cmd)
 	return cmd
 }

--- a/cmd/tendermint/commands/show_node_id.go
+++ b/cmd/tendermint/commands/show_node_id.go
@@ -4,23 +4,21 @@ import (
 	"fmt"

 	"github.com/spf13/cobra"
-
-	"github.com/tendermint/tendermint/config"
 )

-// MakeShowNodeIDCommand constructs a command to dump the node ID to stdout.
-func MakeShowNodeIDCommand(conf *config.Config) *cobra.Command {
-	return &cobra.Command{
-		Use:   "show-node-id",
-		Short: "Show this node's ID",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			nodeKeyID, err := conf.LoadNodeKeyID()
-			if err != nil {
-				return err
-			}
-
-			fmt.Println(nodeKeyID)
-			return nil
-		},
-	}
+// ShowNodeIDCmd dumps node's ID to the standard output.
+var ShowNodeIDCmd = &cobra.Command{
+	Use:   "show-node-id",
+	Short: "Show this node's ID",
+	RunE:  showNodeID,
+}
+
+func showNodeID(cmd *cobra.Command, args []string) error {
+	nodeKeyID, err := config.LoadNodeKeyID()
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(nodeKeyID)
+	return nil
 }
--- a/cmd/tendermint/commands/show_validator.go
+++ b/cmd/tendermint/commands/show_validator.go
@@ -6,78 +6,74 @@ import (

 	"github.com/spf13/cobra"

-	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/internal/jsontypes"
-	"github.com/tendermint/tendermint/libs/log"
+	tmjson "github.com/tendermint/tendermint/libs/json"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 	tmos "github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/privval"
 	tmgrpc "github.com/tendermint/tendermint/privval/grpc"
 )

-// MakeShowValidatorCommand constructs a command to show the validator info.
-func MakeShowValidatorCommand(conf *config.Config, logger log.Logger) *cobra.Command {
-	return &cobra.Command{
-		Use:   "show-validator",
-		Short: "Show this node's validator info",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			var (
-				pubKey crypto.PubKey
-				err    error
-				bctx   = cmd.Context()
-			)
-			//TODO: remove once gRPC is the only supported protocol
-			protocol, _ := tmnet.ProtocolAndAddress(conf.PrivValidator.ListenAddr)
-			switch protocol {
-			case "grpc":
-				pvsc, err := tmgrpc.DialRemoteSigner(
-					bctx,
-					conf.PrivValidator,
-					conf.ChainID(),
-					logger,
-					conf.Instrumentation.Prometheus,
-				)
-				if err != nil {
-					return fmt.Errorf("can't connect to remote validator %w", err)
-				}
+// ShowValidatorCmd adds capabilities for showing the validator info.
+var ShowValidatorCmd = &cobra.Command{
+	Use:   "show-validator",
+	Short: "Show this node's validator info",
+	RunE:  showValidator,
+}

-				ctx, cancel := context.WithTimeout(bctx, ctxTimeout)
-				defer cancel()
+func showValidator(cmd *cobra.Command, args []string) error {
+	var (
+		pubKey crypto.PubKey
+		err    error
+	)

-				pubKey, err = pvsc.GetPubKey(ctx)
-				if err != nil {
-					return fmt.Errorf("can't get pubkey: %w", err)
-				}
-			default:
+	//TODO: remove once gRPC is the only supported protocol
+	protocol, _ := tmnet.ProtocolAndAddress(config.PrivValidator.ListenAddr)
+	switch protocol {
+	case "grpc":
+		pvsc, err := tmgrpc.DialRemoteSigner(
+			config.PrivValidator,
+			config.ChainID(),
+			logger,
+			config.Instrumentation.Prometheus,
+		)
+		if err != nil {
+			return fmt.Errorf("can't connect to remote validator %w", err)
+		}

-				keyFilePath := conf.PrivValidator.KeyFile()
-				if !tmos.FileExists(keyFilePath) {
-					return fmt.Errorf("private validator file %s does not exist", keyFilePath)
-				}
+		ctx, cancel := context.WithTimeout(context.TODO(), ctxTimeout)
+		defer cancel()

-				pv, err := privval.LoadFilePV(keyFilePath, conf.PrivValidator.StateFile())
-				if err != nil {
-					return err
-				}
+		pubKey, err = pvsc.GetPubKey(ctx)
+		if err != nil {
+			return fmt.Errorf("can't get pubkey: %w", err)
+		}
+	default:

-				ctx, cancel := context.WithTimeout(bctx, ctxTimeout)
-				defer cancel()
+		keyFilePath := config.PrivValidator.KeyFile()
+		if !tmos.FileExists(keyFilePath) {
+			return fmt.Errorf("private validator file %s does not exist", keyFilePath)
+		}

-				pubKey, err = pv.GetPubKey(ctx)
-				if err != nil {
-					return fmt.Errorf("can't get pubkey: %w", err)
-				}
-			}
+		pv, err := privval.LoadFilePV(keyFilePath, config.PrivValidator.StateFile())
+		if err != nil {
+			return err
+		}

-			bz, err := jsontypes.Marshal(pubKey)
-			if err != nil {
-				return fmt.Errorf("failed to marshal private validator pubkey: %w", err)
-			}
+		ctx, cancel := context.WithTimeout(context.TODO(), ctxTimeout)
+		defer cancel()

-			fmt.Println(string(bz))
-			return nil
-		},
+		pubKey, err = pv.GetPubKey(ctx)
+		if err != nil {
+			return fmt.Errorf("can't get pubkey: %w", err)
+		}
 	}

+	bz, err := tmjson.Marshal(pubKey)
+	if err != nil {
+		return fmt.Errorf("failed to marshal private validator pubkey: %w", err)
+	}
+
+	fmt.Println(string(bz))
+	return nil
 }
--- a/cmd/tendermint/commands/testnet.go
+++ b/cmd/tendermint/commands/testnet.go
@@ -13,23 +13,76 @@ import (

 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/bytes"
-	"github.com/tendermint/tendermint/libs/log"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmtime "github.com/tendermint/tendermint/libs/time"
 	"github.com/tendermint/tendermint/privval"
 	"github.com/tendermint/tendermint/types"
 )

+var (
+	nValidators    int
+	nNonValidators int
+	initialHeight  int64
+	configFile     string
+	outputDir      string
+	nodeDirPrefix  string
+
+	populatePersistentPeers bool
+	hostnamePrefix          string
+	hostnameSuffix          string
+	startingIPAddress       string
+	hostnames               []string
+	p2pPort                 int
+	randomMonikers          bool
+)
+
 const (
 	nodeDirPerm = 0755
 )

-// MakeTestnetFilesCommand constructs a command to generate testnet config files.
-func MakeTestnetFilesCommand(conf *cfg.Config, logger log.Logger) *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "testnet",
-		Short: "Initialize files for a Tendermint testnet",
-		Long: `testnet will create "v" + "n" number of directories and populate each with
+func init() {
+	TestnetFilesCmd.Flags().IntVar(&nValidators, "v", 4,
+		"number of validators to initialize the testnet with")
+	TestnetFilesCmd.Flags().StringVar(&configFile, "config", "",
+		"config file to use (note some options may be overwritten)")
+	TestnetFilesCmd.Flags().IntVar(&nNonValidators, "n", 0,
+		"number of non-validators to initialize the testnet with")
+	TestnetFilesCmd.Flags().StringVar(&outputDir, "o", "./mytestnet",
+		"directory to store initialization data for the testnet")
+	TestnetFilesCmd.Flags().StringVar(&nodeDirPrefix, "node-dir-prefix", "node",
+		"prefix the directory name for each node with (node results in node0, node1, ...)")
+	TestnetFilesCmd.Flags().Int64Var(&initialHeight, "initial-height", 0,
+		"initial height of the first block")
+
+	TestnetFilesCmd.Flags().BoolVar(&populatePersistentPeers, "populate-persistent-peers", true,
+		"update config of each node with the list of persistent peers build using either"+
+			" hostname-prefix or"+
+			" starting-ip-address")
+	TestnetFilesCmd.Flags().StringVar(&hostnamePrefix, "hostname-prefix", "node",
+		"hostname prefix (\"node\" results in persistent peers list ID0@node0:26656, ID1@node1:26656, ...)")
+	TestnetFilesCmd.Flags().StringVar(&hostnameSuffix, "hostname-suffix", "",
+		"hostname suffix ("+
+			"\".xyz.com\""+
+			" results in persistent peers list ID0@node0.xyz.com:26656, ID1@node1.xyz.com:26656, ...)")
+	TestnetFilesCmd.Flags().StringVar(&startingIPAddress, "starting-ip-address", "",
+		"starting IP address ("+
+			"\"192.168.0.1\""+
+			" results in persistent peers list ID0@192.168.0.1:26656, ID1@192.168.0.2:26656, ...)")
+	TestnetFilesCmd.Flags().StringArrayVar(&hostnames, "hostname", []string{},
+		"manually override all hostnames of validators and non-validators (use --hostname multiple times for multiple hosts)")
+	TestnetFilesCmd.Flags().IntVar(&p2pPort, "p2p-port", 26656,
+		"P2P Port")
+	TestnetFilesCmd.Flags().BoolVar(&randomMonikers, "random-monikers", false,
+		"randomize the moniker for each generated node")
+	TestnetFilesCmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
+		"Key type to generate privval file with. Options: ed25519, secp256k1")
+}
+
+// TestnetFilesCmd allows initialisation of files for a Tendermint testnet.
+var TestnetFilesCmd = &cobra.Command{
+	Use:   "testnet",
+	Short: "Initialize files for a Tendermint testnet",
+	Long: `testnet will create "v" + "n" number of directories and populate each with
 necessary files (private validator, genesis, config, etc.).

 Note, strict routability for addresses is turned off in the config file.
@@ -40,292 +93,205 @@ Example:

 	tendermint testnet --v 4 --o ./output --populate-persistent-peers --starting-ip-address 192.168.10.2
 	`,
-	}
-	var (
-		nValidators    int
-		nNonValidators int
-		initialHeight  int64
-		configFile     string
-		outputDir      string
-		nodeDirPrefix  string
+	RunE: testnetFiles,
+}

-		populatePersistentPeers bool
-		hostnamePrefix          string
-		hostnameSuffix          string
-		startingIPAddress       string
-		hostnames               []string
-		p2pPort                 int
-		randomMonikers          bool
-		keyType                 string
-	)
-
-	cmd.Flags().IntVar(&nValidators, "v", 4,
-		"number of validators to initialize the testnet with")
-	cmd.Flags().StringVar(&configFile, "config", "",
-		"config file to use (note some options may be overwritten)")
-	cmd.Flags().IntVar(&nNonValidators, "n", 0,
-		"number of non-validators to initialize the testnet with")
-	cmd.Flags().StringVar(&outputDir, "o", "./mytestnet",
-		"directory to store initialization data for the testnet")
-	cmd.Flags().StringVar(&nodeDirPrefix, "node-dir-prefix", "node",
-		"prefix the directory name for each node with (node results in node0, node1, ...)")
-	cmd.Flags().Int64Var(&initialHeight, "initial-height", 0,
-		"initial height of the first block")
-
-	cmd.Flags().BoolVar(&populatePersistentPeers, "populate-persistent-peers", true,
-		"update config of each node with the list of persistent peers build using either"+
-			" hostname-prefix or"+
-			" starting-ip-address")
-	cmd.Flags().StringVar(&hostnamePrefix, "hostname-prefix", "node",
-		"hostname prefix (\"node\" results in persistent peers list ID0@node0:26656, ID1@node1:26656, ...)")
-	cmd.Flags().StringVar(&hostnameSuffix, "hostname-suffix", "",
-		"hostname suffix ("+
-			"\".xyz.com\""+
-			" results in persistent peers list ID0@node0.xyz.com:26656, ID1@node1.xyz.com:26656, ...)")
-	cmd.Flags().StringVar(&startingIPAddress, "starting-ip-address", "",
-		"starting IP address ("+
-			"\"192.168.0.1\""+
-			" results in persistent peers list ID0@192.168.0.1:26656, ID1@192.168.0.2:26656, ...)")
-	cmd.Flags().StringArrayVar(&hostnames, "hostname", []string{},
-		"manually override all hostnames of validators and non-validators (use --hostname multiple times for multiple hosts)")
-	cmd.Flags().IntVar(&p2pPort, "p2p-port", 26656,
-		"P2P Port")
-	cmd.Flags().BoolVar(&randomMonikers, "random-monikers", false,
-		"randomize the moniker for each generated node")
-	cmd.Flags().StringVar(&keyType, "key", types.ABCIPubKeyTypeEd25519,
-		"Key type to generate privval file with. Options: ed25519, secp256k1")
-
-	cmd.RunE = func(cmd *cobra.Command, args []string) error {
-		if len(hostnames) > 0 && len(hostnames) != (nValidators+nNonValidators) {
-			return fmt.Errorf(
-				"testnet needs precisely %d hostnames (number of validators plus non-validators) if --hostname parameter is used",
-				nValidators+nNonValidators,
-			)
-		}
-
-		// set mode to validator for testnet
-		config := cfg.DefaultValidatorConfig()
-
-		// overwrite default config if set and valid
-		if configFile != "" {
-			viper.SetConfigFile(configFile)
-			if err := viper.ReadInConfig(); err != nil {
-				return err
-			}
-			if err := viper.Unmarshal(config); err != nil {
-				return err
-			}
-			if err := config.ValidateBasic(); err != nil {
-				return err
-			}
-		}
-
-		genVals := make([]types.GenesisValidator, nValidators)
-		ctx := cmd.Context()
-		for i := 0; i < nValidators; i++ {
-			nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i)
-			nodeDir := filepath.Join(outputDir, nodeDirName)
-			config.SetRoot(nodeDir)
-
-			err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm)
-			if err != nil {
-				_ = os.RemoveAll(outputDir)
-				return err
-			}
-			err = os.MkdirAll(filepath.Join(nodeDir, "data"), nodeDirPerm)
-			if err != nil {
-				_ = os.RemoveAll(outputDir)
-				return err
-			}
-
-			if err := initFilesWithConfig(ctx, config, logger, keyType); err != nil {
-				return err
-			}
-
-			pvKeyFile := filepath.Join(nodeDir, config.PrivValidator.Key)
-			pvStateFile := filepath.Join(nodeDir, config.PrivValidator.State)
-			pv, err := privval.LoadFilePV(pvKeyFile, pvStateFile)
-			if err != nil {
-				return err
-			}
-
-			ctx, cancel := context.WithTimeout(ctx, ctxTimeout)
-			defer cancel()
-
-			pubKey, err := pv.GetPubKey(ctx)
-			if err != nil {
-				return fmt.Errorf("can't get pubkey: %w", err)
-			}
-			genVals[i] = types.GenesisValidator{
-				Address: pubKey.Address(),
-				PubKey:  pubKey,
-				Power:   1,
-				Name:    nodeDirName,
-			}
-		}
-
-		for i := 0; i < nNonValidators; i++ {
-			nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i+nValidators))
-			config.SetRoot(nodeDir)
-
-			err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm)
-			if err != nil {
-				_ = os.RemoveAll(outputDir)
-				return err
-			}
-
-			err = os.MkdirAll(filepath.Join(nodeDir, "data"), nodeDirPerm)
-			if err != nil {
-				_ = os.RemoveAll(outputDir)
-				return err
-			}
-
-			if err := initFilesWithConfig(ctx, conf, logger, keyType); err != nil {
-				return err
-			}
-		}
-
-		// Generate genesis doc from generated validators
-		genDoc := &types.GenesisDoc{
-			ChainID:         "chain-" + tmrand.Str(6),
-			GenesisTime:     tmtime.Now(),
-			InitialHeight:   initialHeight,
-			Validators:      genVals,
-			ConsensusParams: types.DefaultConsensusParams(),
-		}
-		if keyType == "secp256k1" {
-			genDoc.ConsensusParams.Validator = types.ValidatorParams{
-				PubKeyTypes: []string{types.ABCIPubKeyTypeSecp256k1},
-			}
-		}
-
-		// Write genesis file.
-		for i := 0; i < nValidators+nNonValidators; i++ {
-			nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
-			if err := genDoc.SaveAs(filepath.Join(nodeDir, config.BaseConfig.Genesis)); err != nil {
-				_ = os.RemoveAll(outputDir)
-				return err
-			}
-		}
-
-		// Gather persistent peer addresses.
-		var (
-			persistentPeers = make([]string, 0)
-			err             error
+func testnetFiles(cmd *cobra.Command, args []string) error {
+	if len(hostnames) > 0 && len(hostnames) != (nValidators+nNonValidators) {
+		return fmt.Errorf(
+			"testnet needs precisely %d hostnames (number of validators plus non-validators) if --hostname parameter is used",
+			nValidators+nNonValidators,
 		)
-		tpargs := testnetPeerArgs{
-			numValidators:    nValidators,
-			numNonValidators: nNonValidators,
-			peerToPeerPort:   p2pPort,
-			nodeDirPrefix:    nodeDirPrefix,
-			outputDir:        outputDir,
-			hostnames:        hostnames,
-			startingIPAddr:   startingIPAddress,
-			hostnamePrefix:   hostnamePrefix,
-			hostnameSuffix:   hostnameSuffix,
-			randomMonikers:   randomMonikers,
+	}
+
+	// set mode to validator for testnet
+	config := cfg.DefaultValidatorConfig()
+
+	// overwrite default config if set and valid
+	if configFile != "" {
+		viper.SetConfigFile(configFile)
+		if err := viper.ReadInConfig(); err != nil {
+			return err
+		}
+		if err := viper.Unmarshal(config); err != nil {
+			return err
+		}
+		if err := config.ValidateBasic(); err != nil {
+			return err
+		}
+	}
+
+	genVals := make([]types.GenesisValidator, nValidators)
+
+	for i := 0; i < nValidators; i++ {
+		nodeDirName := fmt.Sprintf("%s%d", nodeDirPrefix, i)
+		nodeDir := filepath.Join(outputDir, nodeDirName)
+		config.SetRoot(nodeDir)
+
+		err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+		err = os.MkdirAll(filepath.Join(nodeDir, "data"), nodeDirPerm)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
 		}

+		if err := initFilesWithConfig(config); err != nil {
+			return err
+		}
+
+		pvKeyFile := filepath.Join(nodeDir, config.PrivValidator.Key)
+		pvStateFile := filepath.Join(nodeDir, config.PrivValidator.State)
+		pv, err := privval.LoadFilePV(pvKeyFile, pvStateFile)
+		if err != nil {
+			return err
+		}
+
+		ctx, cancel := context.WithTimeout(context.TODO(), ctxTimeout)
+		defer cancel()
+
+		pubKey, err := pv.GetPubKey(ctx)
+		if err != nil {
+			return fmt.Errorf("can't get pubkey: %w", err)
+		}
+		genVals[i] = types.GenesisValidator{
+			Address: pubKey.Address(),
+			PubKey:  pubKey,
+			Power:   1,
+			Name:    nodeDirName,
+		}
+	}
+
+	for i := 0; i < nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i+nValidators))
+		config.SetRoot(nodeDir)
+
+		err := os.MkdirAll(filepath.Join(nodeDir, "config"), nodeDirPerm)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		err = os.MkdirAll(filepath.Join(nodeDir, "data"), nodeDirPerm)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+
+		if err := initFilesWithConfig(config); err != nil {
+			return err
+		}
+	}
+
+	// Generate genesis doc from generated validators
+	genDoc := &types.GenesisDoc{
+		ChainID:         "chain-" + tmrand.Str(6),
+		GenesisTime:     tmtime.Now(),
+		InitialHeight:   initialHeight,
+		Validators:      genVals,
+		ConsensusParams: types.DefaultConsensusParams(),
+	}
+	if keyType == "secp256k1" {
+		genDoc.ConsensusParams.Validator = types.ValidatorParams{
+			PubKeyTypes: []string{types.ABCIPubKeyTypeSecp256k1},
+		}
+	}
+
+	// Write genesis file.
+	for i := 0; i < nValidators+nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
+		if err := genDoc.SaveAs(filepath.Join(nodeDir, config.BaseConfig.Genesis)); err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+	}
+
+	// Gather persistent peer addresses.
+	var (
+		persistentPeers = make([]string, 0)
+		err             error
+	)
+	if populatePersistentPeers {
+		persistentPeers, err = persistentPeersArray(config)
+		if err != nil {
+			_ = os.RemoveAll(outputDir)
+			return err
+		}
+	}
+
+	// Overwrite default config.
+	for i := 0; i < nValidators+nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
+		config.SetRoot(nodeDir)
+		config.P2P.AllowDuplicateIP = true
 		if populatePersistentPeers {
-
-			persistentPeers, err = persistentPeersArray(config, tpargs)
-			if err != nil {
-				_ = os.RemoveAll(outputDir)
-				return err
-			}
-		}
-
-		// Overwrite default config.
-		for i := 0; i < nValidators+nNonValidators; i++ {
-			nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
-			config.SetRoot(nodeDir)
-			config.P2P.AllowDuplicateIP = true
-			if populatePersistentPeers {
-				persistentPeersWithoutSelf := make([]string, 0)
-				for j := 0; j < len(persistentPeers); j++ {
-					if j == i {
-						continue
-					}
-					persistentPeersWithoutSelf = append(persistentPeersWithoutSelf, persistentPeers[j])
+			persistentPeersWithoutSelf := make([]string, 0)
+			for j := 0; j < len(persistentPeers); j++ {
+				if j == i {
+					continue
 				}
-				config.P2P.PersistentPeers = strings.Join(persistentPeersWithoutSelf, ",")
-			}
-			config.Moniker = tpargs.moniker(i)
-
-			if err := cfg.WriteConfigFile(nodeDir, config); err != nil {
-				return err
+				persistentPeersWithoutSelf = append(persistentPeersWithoutSelf, persistentPeers[j])
 			}
+			config.P2P.PersistentPeers = strings.Join(persistentPeersWithoutSelf, ",")
 		}
+		config.Moniker = moniker(i)

-		fmt.Printf("Successfully initialized %v node directories\n", nValidators+nNonValidators)
-		return nil
+		if err := cfg.WriteConfigFile(nodeDir, config); err != nil {
+			return err
+		}
 	}

-	return cmd
+	fmt.Printf("Successfully initialized %v node directories\n", nValidators+nNonValidators)
+	return nil
 }

-type testnetPeerArgs struct {
-	numValidators    int
-	numNonValidators int
-	peerToPeerPort   int
-	nodeDirPrefix    string
-	outputDir        string
-	hostnames        []string
-	startingIPAddr   string
-	hostnamePrefix   string
-	hostnameSuffix   string
-	randomMonikers   bool
-}
-
-func (args *testnetPeerArgs) hostnameOrIP(i int) (string, error) {
-	if len(args.hostnames) > 0 && i < len(args.hostnames) {
-		return args.hostnames[i], nil
+func hostnameOrIP(i int) string {
+	if len(hostnames) > 0 && i < len(hostnames) {
+		return hostnames[i]
 	}
-	if args.startingIPAddr == "" {
-		return fmt.Sprintf("%s%d%s", args.hostnamePrefix, i, args.hostnameSuffix), nil
+	if startingIPAddress == "" {
+		return fmt.Sprintf("%s%d%s", hostnamePrefix, i, hostnameSuffix)
 	}
-	ip := net.ParseIP(args.startingIPAddr)
+	ip := net.ParseIP(startingIPAddress)
 	ip = ip.To4()
 	if ip == nil {
-		return "", fmt.Errorf("%v is non-ipv4 address", args.startingIPAddr)
+		fmt.Printf("%v: non ipv4 address\n", startingIPAddress)
+		os.Exit(1)
 	}

 	for j := 0; j < i; j++ {
 		ip[3]++
 	}
-	return ip.String(), nil
-
+	return ip.String()
 }

 // get an array of persistent peers
-func persistentPeersArray(config *cfg.Config, args testnetPeerArgs) ([]string, error) {
-	peers := make([]string, args.numValidators+args.numNonValidators)
-	for i := 0; i < len(peers); i++ {
-		nodeDir := filepath.Join(args.outputDir, fmt.Sprintf("%s%d", args.nodeDirPrefix, i))
+func persistentPeersArray(config *cfg.Config) ([]string, error) {
+	peers := make([]string, nValidators+nNonValidators)
+	for i := 0; i < nValidators+nNonValidators; i++ {
+		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
 		config.SetRoot(nodeDir)
 		nodeKey, err := config.LoadNodeKeyID()
 		if err != nil {
-			return nil, err
+			return []string{}, err
 		}
-		addr, err := args.hostnameOrIP(i)
-		if err != nil {
-			return nil, err
-		}
-
-		peers[i] = nodeKey.AddressString(fmt.Sprintf("%s:%d", addr, args.peerToPeerPort))
+		peers[i] = nodeKey.AddressString(fmt.Sprintf("%s:%d", hostnameOrIP(i), p2pPort))
 	}
 	return peers, nil
 }

-func (args *testnetPeerArgs) moniker(i int) string {
-	if args.randomMonikers {
+func moniker(i int) string {
+	if randomMonikers {
 		return randomMoniker()
 	}
-	if len(args.hostnames) > 0 && i < len(args.hostnames) {
-		return args.hostnames[i]
+	if len(hostnames) > 0 && i < len(hostnames) {
+		return hostnames[i]
 	}
-	if args.startingIPAddr == "" {
-		return fmt.Sprintf("%s%d%s", args.hostnamePrefix, i, args.hostnameSuffix)
+	if startingIPAddress == "" {
+		return fmt.Sprintf("%s%d%s", hostnamePrefix, i, hostnameSuffix)
 	}
 	return randomMoniker()
 }
--- a/cmd/tendermint/main.go
+++ b/cmd/tendermint/main.go
@@ -1,50 +1,37 @@
 package main

 import (
-	"context"
+	"os"
+	"path/filepath"

-	"github.com/tendermint/tendermint/cmd/tendermint/commands"
+	cmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
 	"github.com/tendermint/tendermint/cmd/tendermint/commands/debug"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/cli"
-	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/node"
 )

 func main() {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	conf, err := commands.ParseConfig(config.DefaultConfig())
-	if err != nil {
-		panic(err)
-	}
-
-	logger, err := log.NewDefaultLogger(conf.LogFormat, conf.LogLevel)
-	if err != nil {
-		panic(err)
-	}
-
-	rcmd := commands.RootCommand(conf, logger)
-	rcmd.AddCommand(
-		commands.MakeGenValidatorCommand(),
-		commands.MakeReindexEventCommand(conf, logger),
-		commands.MakeInitFilesCommand(conf, logger),
-		commands.MakeLightCommand(conf, logger),
-		commands.MakeReplayCommand(conf, logger),
-		commands.MakeReplayConsoleCommand(conf, logger),
-		commands.MakeResetAllCommand(conf, logger),
-		commands.MakeResetPrivateValidatorCommand(conf, logger),
-		commands.MakeShowValidatorCommand(conf, logger),
-		commands.MakeTestnetFilesCommand(conf, logger),
-		commands.MakeShowNodeIDCommand(conf),
-		commands.GenNodeKeyCmd,
-		commands.VersionCmd,
-		commands.MakeInspectCommand(conf, logger),
-		commands.MakeRollbackStateCommand(conf),
-		commands.MakeKeyMigrateCommand(conf, logger),
+	rootCmd := cmd.RootCmd
+	rootCmd.AddCommand(
+		cmd.GenValidatorCmd,
+		cmd.ReIndexEventCmd,
+		cmd.InitFilesCmd,
+		cmd.LightCmd,
+		cmd.ReplayCmd,
+		cmd.ReplayConsoleCmd,
+		cmd.ResetAllCmd,
+		cmd.ResetPrivValidatorCmd,
+		cmd.ShowValidatorCmd,
+		cmd.TestnetFilesCmd,
+		cmd.ShowNodeIDCmd,
+		cmd.GenNodeKeyCmd,
+		cmd.VersionCmd,
+		cmd.InspectCmd,
+		cmd.RollbackStateCmd,
+		cmd.MakeKeyMigrateCommand(),
 		debug.DebugCmd,
-		commands.NewCompletionCmd(rcmd, true),
+		cli.NewCompletionCmd(rootCmd, true),
 	)

 	// NOTE:
@@ -58,9 +45,10 @@ func main() {
 	nodeFunc := node.NewDefault

 	// Create & start node
-	rcmd.AddCommand(commands.NewRunNodeCmd(nodeFunc, conf, logger))
+	rootCmd.AddCommand(cmd.NewRunNodeCmd(nodeFunc))

-	if err := cli.RunWithTrace(ctx, rcmd); err != nil {
+	cmd := cli.PrepareBaseCmd(rootCmd, "TM", os.ExpandEnv(filepath.Join("$HOME", config.DefaultTendermintDir)))
+	if err := cmd.Execute(); err != nil {
 		panic(err)
 	}
 }
--- a/config/config.go
+++ b/config/config.go
@@ -2,7 +2,6 @@ package config

 import (
 	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"net/http"
@@ -10,6 +9,7 @@ import (
 	"path/filepath"
 	"time"

+	tmjson "github.com/tendermint/tendermint/libs/json"
 	"github.com/tendermint/tendermint/libs/log"
 	tmos "github.com/tendermint/tendermint/libs/os"
 	"github.com/tendermint/tendermint/types"
@@ -270,7 +270,7 @@ func (cfg BaseConfig) LoadNodeKeyID() (types.NodeID, error) {
 		return "", err
 	}
 	nodeKey := types.NodeKey{}
-	err = json.Unmarshal(jsonBytes, &nodeKey)
+	err = tmjson.Unmarshal(jsonBytes, &nodeKey)
 	if err != nil {
 		return "", err
 	}
@@ -571,11 +571,9 @@ type P2PConfig struct { //nolint: maligned

 	// Comma separated list of seed nodes to connect to
 	// We only use these if we can’t connect to peers in the addrbook
-	//
-	// Deprecated: This value is not used by the new PEX reactor. Use
-	// BootstrapPeers instead.
-	//
-	// TODO(#5670): Remove once the p2p refactor is complete.
+	// NOTE: not used by the new PEX reactor. Please use BootstrapPeers instead.
+	// TODO: Remove once p2p refactor is complete
+	// ref: https://github.com/tendermint/tendermint/issues/5670
 	Seeds string `mapstructure:"seeds"`

 	// Comma separated list of peers to be added to the peer store
@@ -683,6 +681,7 @@ func TestP2PConfig() *P2PConfig {
 	cfg.ListenAddress = "tcp://127.0.0.1:36656"
 	cfg.AllowDuplicateIP = true
 	cfg.FlushThrottleTimeout = 10 * time.Millisecond
+
 	return cfg
 }

--- a/config/config_test.go
+++ b/config/config_test.go
@@ -10,19 +10,21 @@ import (
 )

 func TestDefaultConfig(t *testing.T) {
+	assert := assert.New(t)
+
 	// set up some defaults
 	cfg := DefaultConfig()
-	assert.NotNil(t, cfg.P2P)
-	assert.NotNil(t, cfg.Mempool)
-	assert.NotNil(t, cfg.Consensus)
+	assert.NotNil(cfg.P2P)
+	assert.NotNil(cfg.Mempool)
+	assert.NotNil(cfg.Consensus)

 	// check the root dir stuff...
 	cfg.SetRoot("/foo")
 	cfg.Genesis = "bar"
 	cfg.DBPath = "/opt/data"

-	assert.Equal(t, "/foo/bar", cfg.GenesisFile())
-	assert.Equal(t, "/opt/data", cfg.DBDir())
+	assert.Equal("/foo/bar", cfg.GenesisFile())
+	assert.Equal("/opt/data", cfg.DBDir())
 }

 func TestConfigValidateBasic(t *testing.T) {
@@ -35,18 +37,19 @@ func TestConfigValidateBasic(t *testing.T) {
 }

 func TestTLSConfiguration(t *testing.T) {
+	assert := assert.New(t)
 	cfg := DefaultConfig()
 	cfg.SetRoot("/home/user")

 	cfg.RPC.TLSCertFile = "file.crt"
-	assert.Equal(t, "/home/user/config/file.crt", cfg.RPC.CertFile())
+	assert.Equal("/home/user/config/file.crt", cfg.RPC.CertFile())
 	cfg.RPC.TLSKeyFile = "file.key"
-	assert.Equal(t, "/home/user/config/file.key", cfg.RPC.KeyFile())
+	assert.Equal("/home/user/config/file.key", cfg.RPC.KeyFile())

 	cfg.RPC.TLSCertFile = "/abs/path/to/file.crt"
-	assert.Equal(t, "/abs/path/to/file.crt", cfg.RPC.CertFile())
+	assert.Equal("/abs/path/to/file.crt", cfg.RPC.CertFile())
 	cfg.RPC.TLSKeyFile = "/abs/path/to/file.key"
-	assert.Equal(t, "/abs/path/to/file.key", cfg.RPC.KeyFile())
+	assert.Equal("/abs/path/to/file.key", cfg.RPC.KeyFile())
 }

 func TestBaseConfigValidateBasic(t *testing.T) {
--- a/config/toml.go
+++ b/config/toml.go
@@ -9,7 +9,6 @@ import (
 	"text/template"

 	tmos "github.com/tendermint/tendermint/libs/os"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
 )

 // DefaultDirPerm is the default permissions used when creating directories.
@@ -504,13 +503,13 @@ namespace = "{{ .Instrumentation.Namespace }}"

 /****** these are for test settings ***********/

-func ResetTestRoot(dir, testName string) (*Config, error) {
-	return ResetTestRootWithChainID(dir, testName, "")
+func ResetTestRoot(testName string) (*Config, error) {
+	return ResetTestRootWithChainID(testName, "")
 }

-func ResetTestRootWithChainID(dir, testName string, chainID string) (*Config, error) {
+func ResetTestRootWithChainID(testName string, chainID string) (*Config, error) {
 	// create a unique, concurrency-safe test directory under os.TempDir()
-	rootDir, err := os.MkdirTemp(dir, fmt.Sprintf("%s-%s_", chainID, testName))
+	rootDir, err := os.MkdirTemp("", fmt.Sprintf("%s-%s_", chainID, testName))
 	if err != nil {
 		return nil, err
 	}
@@ -550,7 +549,6 @@ func ResetTestRootWithChainID(dir, testName string, chainID string) (*Config, er
 	}

 	config := TestConfig().SetRoot(rootDir)
-	config.Instrumentation.Namespace = fmt.Sprintf("%s_%s_%s", testName, chainID, tmrand.Str(16))
 	return config, nil
 }

@@ -571,10 +569,6 @@ var testGenesisFmt = `{
 			"max_gas": "-1",
 			"time_iota_ms": "10"
 		},
-		"synchrony": {
-			"message_delay": "500000000",
-			"precision": "10000000"
-		},
 		"evidence": {
 			"max_age_num_blocks": "100000",
 			"max_age_duration": "172800000000000",
--- a/config/toml_test.go
+++ b/config/toml_test.go
@@ -14,22 +14,26 @@ func ensureFiles(t *testing.T, rootDir string, files ...string) {
 	for _, f := range files {
 		p := rootify(rootDir, f)
 		_, err := os.Stat(p)
-		assert.NoError(t, err, p)
+		assert.Nil(t, err, p)
 	}
 }

 func TestEnsureRoot(t *testing.T) {
+	require := require.New(t)
+
 	// setup temp dir for test
-	tmpDir := t.TempDir()
+	tmpDir, err := os.MkdirTemp("", "config-test")
+	require.NoError(err)
+	defer os.RemoveAll(tmpDir)

 	// create root dir
 	EnsureRoot(tmpDir)

-	require.NoError(t, WriteConfigFile(tmpDir, DefaultConfig()))
+	require.NoError(WriteConfigFile(tmpDir, DefaultConfig()))

 	// make sure config is set properly
 	data, err := os.ReadFile(filepath.Join(tmpDir, defaultConfigFilePath))
-	require.NoError(t, err)
+	require.NoError(err)

 	checkConfig(t, string(data))

@@ -37,17 +41,19 @@ func TestEnsureRoot(t *testing.T) {
 }

 func TestEnsureTestRoot(t *testing.T) {
+	require := require.New(t)
+
 	testName := "ensureTestRoot"

 	// create root dir
-	cfg, err := ResetTestRoot(t.TempDir(), testName)
-	require.NoError(t, err)
+	cfg, err := ResetTestRoot(testName)
+	require.NoError(err)
 	defer os.RemoveAll(cfg.RootDir)
 	rootDir := cfg.RootDir

 	// make sure config is set properly
 	data, err := os.ReadFile(filepath.Join(rootDir, defaultConfigFilePath))
-	require.NoError(t, err)
+	require.Nil(err)

 	checkConfig(t, string(data))

--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -2,7 +2,6 @@ package crypto

 import (
 	"github.com/tendermint/tendermint/crypto/tmhash"
-	"github.com/tendermint/tendermint/internal/jsontypes"
 	"github.com/tendermint/tendermint/libs/bytes"
 )

@@ -26,9 +25,6 @@ type PubKey interface {
 	VerifySignature(msg []byte, sig []byte) bool
 	Equals(PubKey) bool
 	Type() string
-
-	// Implementations must support tagged encoding in JSON.
-	jsontypes.Tagged
 }

 type PrivKey interface {
@@ -37,9 +33,6 @@ type PrivKey interface {
 	PubKey() PubKey
 	Equals(PrivKey) bool
 	Type() string
-
-	// Implementations must support tagged encoding in JSON.
-	jsontypes.Tagged
 }

 type Symmetric interface {
--- a/crypto/ed25519/bench_test.go
+++ b/crypto/ed25519/bench_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"

 	"github.com/stretchr/testify/require"
-
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/internal/benchmarking"
 )
--- a/crypto/ed25519/ed25519.go
+++ b/crypto/ed25519/ed25519.go
@@ -12,7 +12,7 @@ import (

 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/tmhash"
-	"github.com/tendermint/tendermint/internal/jsontypes"
+	tmjson "github.com/tendermint/tendermint/libs/json"
 )

 //-------------------------------------
@@ -56,16 +56,13 @@ const (
 )

 func init() {
-	jsontypes.MustRegister(PubKey{})
-	jsontypes.MustRegister(PrivKey{})
+	tmjson.RegisterType(PubKey{}, PubKeyName)
+	tmjson.RegisterType(PrivKey{}, PrivKeyName)
 }

 // PrivKey implements crypto.PrivKey.
 type PrivKey []byte

-// TypeTag satisfies the jsontypes.Tagged interface.
-func (PrivKey) TypeTag() string { return PrivKeyName }
-
 // Bytes returns the privkey byte format.
 func (privKey PrivKey) Bytes() []byte {
 	return []byte(privKey)
@@ -154,9 +151,6 @@ var _ crypto.PubKey = PubKey{}
 // PubKeyEd25519 implements crypto.PubKey for the Ed25519 signature scheme.
 type PubKey []byte

-// TypeTag satisfies the jsontypes.Tagged interface.
-func (PubKey) TypeTag() string { return PubKeyName }
-
 // Address is the SHA256-20 of the raw pubkey bytes.
 func (pubKey PubKey) Address() crypto.Address {
 	if len(pubKey) != PubKeySize {
--- a/crypto/ed25519/ed25519_test.go
+++ b/crypto/ed25519/ed25519_test.go
@@ -17,7 +17,7 @@ func TestSignAndValidateEd25519(t *testing.T) {

 	msg := crypto.CRandBytes(128)
 	sig, err := privKey.Sign(msg)
-	require.NoError(t, err)
+	require.Nil(t, err)

 	// Test the signature
 	assert.True(t, pubKey.VerifySignature(msg, sig))
--- a/crypto/encoding/codec.go
+++ b/crypto/encoding/codec.go
@@ -7,14 +7,14 @@ import (
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/crypto/secp256k1"
 	"github.com/tendermint/tendermint/crypto/sr25519"
-	"github.com/tendermint/tendermint/internal/jsontypes"
+	"github.com/tendermint/tendermint/libs/json"
 	cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 )

 func init() {
-	jsontypes.MustRegister((*cryptoproto.PublicKey)(nil))
-	jsontypes.MustRegister((*cryptoproto.PublicKey_Ed25519)(nil))
-	jsontypes.MustRegister((*cryptoproto.PublicKey_Secp256K1)(nil))
+	json.RegisterType((*cryptoproto.PublicKey)(nil), "tendermint.crypto.PublicKey")
+	json.RegisterType((*cryptoproto.PublicKey_Ed25519)(nil), "tendermint.crypto.PublicKey_Ed25519")
+	json.RegisterType((*cryptoproto.PublicKey_Secp256K1)(nil), "tendermint.crypto.PublicKey_Secp256K1")
 }

 // PubKeyToProto takes crypto.PubKey and transforms it to a protobuf Pubkey
--- a/crypto/merkle/proof.go
+++ b/crypto/merkle/proof.go
@@ -24,10 +24,10 @@ const (
 // everything.  This also affects the generalized proof system as
 // well.
 type Proof struct {
-	Total    int64    `json:"total,string"` // Total number of items.
-	Index    int64    `json:"index,string"` // Index of item to prove.
-	LeafHash []byte   `json:"leaf_hash"`    // Hash of item value.
-	Aunts    [][]byte `json:"aunts"`        // Hashes from leaf's sibling to a root's child.
+	Total    int64    `json:"total"`     // Total number of items.
+	Index    int64    `json:"index"`     // Index of item to prove.
+	LeafHash []byte   `json:"leaf_hash"` // Hash of item value.
+	Aunts    [][]byte `json:"aunts"`     // Hashes from leaf's sibling to a root's child.
 }

 // ProofsFromByteSlices computes inclusion proof for given items.
--- a/crypto/merkle/proof_key_path_test.go
+++ b/crypto/merkle/proof_key_path_test.go
@@ -28,13 +28,13 @@ func TestKeyPath(t *testing.T) {
 			case KeyEncodingHex:
 				rand.Read(keys[i])
 			default:
-				require.Fail(t, "Unexpected encoding")
+				panic("Unexpected encoding")
 			}
 			path = path.AppendKey(keys[i], enc)
 		}

 		res, err := KeyPathToKeys(path.String())
-		require.NoError(t, err)
+		require.Nil(t, err)
 		require.Equal(t, len(keys), len(res))

 		for i, key := range keys {
--- a/crypto/merkle/proof_test.go
+++ b/crypto/merkle/proof_test.go
@@ -79,58 +79,58 @@ func TestProofOperators(t *testing.T) {
 	// Good
 	popz := ProofOperators([]ProofOperator{op1, op2, op3, op4})
 	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.NoError(t, err)
+	assert.Nil(t, err)
 	err = popz.VerifyValue(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", bz("INPUT1"))
-	assert.NoError(t, err)
+	assert.Nil(t, err)

 	// BAD INPUT
 	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1_WRONG")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)
 	err = popz.VerifyValue(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", bz("INPUT1_WRONG"))
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD KEY 1
 	err = popz.Verify(bz("OUTPUT4"), "/KEY3/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD KEY 2
 	err = popz.Verify(bz("OUTPUT4"), "KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD KEY 3
 	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1/", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD KEY 4
 	err = popz.Verify(bz("OUTPUT4"), "//KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD KEY 5
 	err = popz.Verify(bz("OUTPUT4"), "/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD OUTPUT 1
 	err = popz.Verify(bz("OUTPUT4_WRONG"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD OUTPUT 2
 	err = popz.Verify(bz(""), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD POPZ 1
 	popz = []ProofOperator{op1, op2, op4}
 	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD POPZ 2
 	popz = []ProofOperator{op4, op3, op2, op1}
 	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)

 	// BAD POPZ 3
 	popz = []ProofOperator{}
 	err = popz.Verify(bz("OUTPUT4"), "/KEY4/KEY2/KEY1", [][]byte{bz("INPUT1")})
-	assert.Error(t, err)
+	assert.NotNil(t, err)
 }

 func bz(s string) []byte {
--- a/crypto/secp256k1/secp256k1.go
+++ b/crypto/secp256k1/secp256k1.go
@@ -9,12 +9,11 @@ import (
 	"math/big"

 	secp256k1 "github.com/btcsuite/btcd/btcec"
-
 	"github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/internal/jsontypes"
+	tmjson "github.com/tendermint/tendermint/libs/json"

 	// necessary for Bitcoin address format
-	"golang.org/x/crypto/ripemd160" //nolint:staticcheck
+	"golang.org/x/crypto/ripemd160" // nolint
 )

 //-------------------------------------
@@ -27,8 +26,8 @@ const (
 )

 func init() {
-	jsontypes.MustRegister(PubKey{})
-	jsontypes.MustRegister(PrivKey{})
+	tmjson.RegisterType(PubKey{}, PubKeyName)
+	tmjson.RegisterType(PrivKey{}, PrivKeyName)
 }

 var _ crypto.PrivKey = PrivKey{}
@@ -36,9 +35,6 @@ var _ crypto.PrivKey = PrivKey{}
 // PrivKey implements PrivKey.
 type PrivKey []byte

-// TypeTag satisfies the jsontypes.Tagged interface.
-func (PrivKey) TypeTag() string { return PrivKeyName }
-
 // Bytes marshalls the private key using amino encoding.
 func (privKey PrivKey) Bytes() []byte {
 	return []byte(privKey)
@@ -142,9 +138,6 @@ const PubKeySize = 33
 // This prefix is followed with the x-coordinate.
 type PubKey []byte

-// TypeTag satisfies the jsontypes.Tagged interface.
-func (PubKey) TypeTag() string { return PubKeyName }
-
 // Address returns a Bitcoin style addresses: RIPEMD160(SHA256(pubkey))
 func (pubKey PubKey) Address() crypto.Address {
 	if len(pubKey) != PubKeySize {
@@ -179,67 +172,3 @@ func (pubKey PubKey) Equals(other crypto.PubKey) bool {
 func (pubKey PubKey) Type() string {
 	return KeyType
 }
-
-// used to reject malleable signatures
-// see:
-//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
-//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/crypto.go#L39
-var secp256k1halfN = new(big.Int).Rsh(secp256k1.S256().N, 1)
-
-// Sign creates an ECDSA signature on curve Secp256k1, using SHA256 on the msg.
-// The returned signature will be of the form R || S (in lower-S form).
-func (privKey PrivKey) Sign(msg []byte) ([]byte, error) {
-	priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey)
-
-	sig, err := priv.Sign(crypto.Sha256(msg))
-	if err != nil {
-		return nil, err
-	}
-
-	sigBytes := serializeSig(sig)
-	return sigBytes, nil
-}
-
-// VerifySignature verifies a signature of the form R || S.
-// It rejects signatures which are not in lower-S form.
-func (pubKey PubKey) VerifySignature(msg []byte, sigStr []byte) bool {
-	if len(sigStr) != 64 {
-		return false
-	}
-
-	pub, err := secp256k1.ParsePubKey(pubKey, secp256k1.S256())
-	if err != nil {
-		return false
-	}
-
-	// parse the signature:
-	signature := signatureFromBytes(sigStr)
-	// Reject malleable signatures. libsecp256k1 does this check but btcec doesn't.
-	// see: https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
-	if signature.S.Cmp(secp256k1halfN) > 0 {
-		return false
-	}
-
-	return signature.Verify(crypto.Sha256(msg), pub)
-}
-
-// Read Signature struct from R || S. Caller needs to ensure
-// that len(sigStr) == 64.
-func signatureFromBytes(sigStr []byte) *secp256k1.Signature {
-	return &secp256k1.Signature{
-		R: new(big.Int).SetBytes(sigStr[:32]),
-		S: new(big.Int).SetBytes(sigStr[32:64]),
-	}
-}
-
-// Serialize signature to R || S.
-// R, S are padded to 32 bytes respectively.
-func serializeSig(sig *secp256k1.Signature) []byte {
-	rBytes := sig.R.Bytes()
-	sBytes := sig.S.Bytes()
-	sigBytes := make([]byte, 64)
-	// 0 pad the byte arrays from the left if they aren't big enough.
-	copy(sigBytes[32-len(rBytes):32], rBytes)
-	copy(sigBytes[64-len(sBytes):64], sBytes)
-	return sigBytes
-}
--- a/crypto/secp256k1/secp256k1_nocgo.go
+++ b/crypto/secp256k1/secp256k1_nocgo.go
@@ -0,0 +1,76 @@
+//go:build !libsecp256k1
+// +build !libsecp256k1
+
+package secp256k1
+
+import (
+	"math/big"
+
+	secp256k1 "github.com/btcsuite/btcd/btcec"
+
+	"github.com/tendermint/tendermint/crypto"
+)
+
+// used to reject malleable signatures
+// see:
+//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
+//  - https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/crypto.go#L39
+var secp256k1halfN = new(big.Int).Rsh(secp256k1.S256().N, 1)
+
+// Sign creates an ECDSA signature on curve Secp256k1, using SHA256 on the msg.
+// The returned signature will be of the form R || S (in lower-S form).
+func (privKey PrivKey) Sign(msg []byte) ([]byte, error) {
+	priv, _ := secp256k1.PrivKeyFromBytes(secp256k1.S256(), privKey)
+
+	sig, err := priv.Sign(crypto.Sha256(msg))
+	if err != nil {
+		return nil, err
+	}
+
+	sigBytes := serializeSig(sig)
+	return sigBytes, nil
+}
+
+// VerifySignature verifies a signature of the form R || S.
+// It rejects signatures which are not in lower-S form.
+func (pubKey PubKey) VerifySignature(msg []byte, sigStr []byte) bool {
+	if len(sigStr) != 64 {
+		return false
+	}
+
+	pub, err := secp256k1.ParsePubKey(pubKey, secp256k1.S256())
+	if err != nil {
+		return false
+	}
+
+	// parse the signature:
+	signature := signatureFromBytes(sigStr)
+	// Reject malleable signatures. libsecp256k1 does this check but btcec doesn't.
+	// see: https://github.com/ethereum/go-ethereum/blob/f9401ae011ddf7f8d2d95020b7446c17f8d98dc1/crypto/signature_nocgo.go#L90-L93
+	if signature.S.Cmp(secp256k1halfN) > 0 {
+		return false
+	}
+
+	return signature.Verify(crypto.Sha256(msg), pub)
+}
+
+// Read Signature struct from R || S. Caller needs to ensure
+// that len(sigStr) == 64.
+func signatureFromBytes(sigStr []byte) *secp256k1.Signature {
+	return &secp256k1.Signature{
+		R: new(big.Int).SetBytes(sigStr[:32]),
+		S: new(big.Int).SetBytes(sigStr[32:64]),
+	}
+}
+
+// Serialize signature to R || S.
+// R, S are padded to 32 bytes respectively.
+func serializeSig(sig *secp256k1.Signature) []byte {
+	rBytes := sig.R.Bytes()
+	sBytes := sig.S.Bytes()
+	sigBytes := make([]byte, 64)
+	// 0 pad the byte arrays from the left if they aren't big enough.
+	copy(sigBytes[32-len(rBytes):32], rBytes)
+	copy(sigBytes[64-len(sBytes):64], sBytes)
+	return sigBytes
+}
--- a/crypto/secp256k1/secp256k1_test.go
+++ b/crypto/secp256k1/secp256k1_test.go
@@ -52,7 +52,7 @@ func TestSignAndValidateSecp256k1(t *testing.T) {

 	msg := crypto.CRandBytes(128)
 	sig, err := privKey.Sign(msg)
-	require.NoError(t, err)
+	require.Nil(t, err)

 	assert.True(t, pubKey.VerifySignature(msg, sig))

--- a/crypto/sr25519/bench_test.go
+++ b/crypto/sr25519/bench_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"

 	"github.com/stretchr/testify/require"
-
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/internal/benchmarking"
 )
--- a/crypto/sr25519/encoding.go
+++ b/crypto/sr25519/encoding.go
@@ -1,8 +1,6 @@
 package sr25519

-import (
-	"github.com/tendermint/tendermint/internal/jsontypes"
-)
+import tmjson "github.com/tendermint/tendermint/libs/json"

 const (
 	PrivKeyName = "tendermint/PrivKeySr25519"
@@ -10,6 +8,6 @@ const (
 )

 func init() {
-	jsontypes.MustRegister(PubKey{})
-	jsontypes.MustRegister(PrivKey{})
+	tmjson.RegisterType(PubKey{}, PubKeyName)
+	tmjson.RegisterType(PrivKey{}, PrivKeyName)
 }
--- a/crypto/sr25519/privkey.go
+++ b/crypto/sr25519/privkey.go
@@ -29,9 +29,6 @@ type PrivKey struct {
 	kp  *sr25519.KeyPair
 }

-// TypeTag satisfies the jsontypes.Tagged interface.
-func (PrivKey) TypeTag() string { return PrivKeyName }
-
 // Bytes returns the byte-encoded PrivKey.
 func (privKey PrivKey) Bytes() []byte {
 	if privKey.kp == nil {
--- a/crypto/sr25519/pubkey.go
+++ b/crypto/sr25519/pubkey.go
@@ -23,9 +23,6 @@ const (
 // PubKey implements crypto.PubKey.
 type PubKey []byte

-// TypeTag satisfies the jsontypes.Tagged interface.
-func (PubKey) TypeTag() string { return PubKeyName }
-
 // Address is the SHA256-20 of the raw pubkey bytes.
 func (pubKey PubKey) Address() crypto.Address {
 	if len(pubKey) != PubKeySize {
--- a/crypto/sr25519/sr25519_test.go
+++ b/crypto/sr25519/sr25519_test.go
@@ -18,7 +18,7 @@ func TestSignAndValidateSr25519(t *testing.T) {

 	msg := crypto.CRandBytes(128)
 	sig, err := privKey.Sign(msg)
-	require.NoError(t, err)
+	require.Nil(t, err)

 	// Test the signature
 	assert.True(t, pubKey.VerifySignature(msg, sig))
--- a/crypto/xchacha20poly1305/vector_test.go
+++ b/crypto/xchacha20poly1305/vector_test.go
@@ -0,0 +1,122 @@
+package xchacha20poly1305
+
+import (
+	"bytes"
+	"encoding/hex"
+	"testing"
+)
+
+func toHex(bits []byte) string {
+	return hex.EncodeToString(bits)
+}
+
+func fromHex(bits string) []byte {
+	b, err := hex.DecodeString(bits)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+func TestHChaCha20(t *testing.T) {
+	for i, v := range hChaCha20Vectors {
+		var key [32]byte
+		var nonce [16]byte
+		copy(key[:], v.key)
+		copy(nonce[:], v.nonce)
+
+		HChaCha20(&key, &nonce, &key)
+		if !bytes.Equal(key[:], v.keystream) {
+			t.Errorf("test %d: keystream mismatch:\n \t got:  %s\n \t want: %s", i, toHex(key[:]), toHex(v.keystream))
+		}
+	}
+}
+
+var hChaCha20Vectors = []struct {
+	key, nonce, keystream []byte
+}{
+	{
+		fromHex("0000000000000000000000000000000000000000000000000000000000000000"),
+		fromHex("000000000000000000000000000000000000000000000000"),
+		fromHex("1140704c328d1d5d0e30086cdf209dbd6a43b8f41518a11cc387b669b2ee6586"),
+	},
+	{
+		fromHex("8000000000000000000000000000000000000000000000000000000000000000"),
+		fromHex("000000000000000000000000000000000000000000000000"),
+		fromHex("7d266a7fd808cae4c02a0a70dcbfbcc250dae65ce3eae7fc210f54cc8f77df86"),
+	},
+	{
+		fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
+		fromHex("000000000000000000000000000000000000000000000002"),
+		fromHex("e0c77ff931bb9163a5460c02ac281c2b53d792b1c43fea817e9ad275ae546963"),
+	},
+	{
+		fromHex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"),
+		fromHex("000102030405060708090a0b0c0d0e0f1011121314151617"),
+		fromHex("51e3ff45a895675c4b33b46c64f4a9ace110d34df6a2ceab486372bacbd3eff6"),
+	},
+	{
+		fromHex("24f11cce8a1b3d61e441561a696c1c1b7e173d084fd4812425435a8896a013dc"),
+		fromHex("d9660c5900ae19ddad28d6e06e45fe5e"),
+		fromHex("5966b3eec3bff1189f831f06afe4d4e3be97fa9235ec8c20d08acfbbb4e851e3"),
+	},
+}
+
+func TestVectors(t *testing.T) {
+	for i, v := range vectors {
+		if len(v.plaintext) == 0 {
+			v.plaintext = make([]byte, len(v.ciphertext))
+		}
+
+		var nonce [24]byte
+		copy(nonce[:], v.nonce)
+
+		aead, err := New(v.key)
+		if err != nil {
+			t.Error(err)
+		}
+
+		dst := aead.Seal(nil, nonce[:], v.plaintext, v.ad)
+		if !bytes.Equal(dst, v.ciphertext) {
+			t.Errorf("test %d: ciphertext mismatch:\n \t got:  %s\n \t want: %s", i, toHex(dst), toHex(v.ciphertext))
+		}
+		open, err := aead.Open(nil, nonce[:], dst, v.ad)
+		if err != nil {
+			t.Error(err)
+		}
+		if !bytes.Equal(open, v.plaintext) {
+			t.Errorf("test %d: plaintext mismatch:\n \t got:  %s\n \t want: %s", i, string(open), string(v.plaintext))
+		}
+	}
+}
+
+var vectors = []struct {
+	key, nonce, ad, plaintext, ciphertext []byte
+}{
+	{
+		[]byte{
+			0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+			0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
+			0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+		},
+		[]byte{0x07, 0x00, 0x00, 0x00, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b},
+		[]byte{0x50, 0x51, 0x52, 0x53, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7},
+		[]byte(
+			"Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.",
+		),
+		[]byte{
+			0x45, 0x3c, 0x06, 0x93, 0xa7, 0x40, 0x7f, 0x04, 0xff, 0x4c, 0x56,
+			0xae, 0xdb, 0x17, 0xa3, 0xc0, 0xa1, 0xaf, 0xff, 0x01, 0x17, 0x49,
+			0x30, 0xfc, 0x22, 0x28, 0x7c, 0x33, 0xdb, 0xcf, 0x0a, 0xc8, 0xb8,
+			0x9a, 0xd9, 0x29, 0x53, 0x0a, 0x1b, 0xb3, 0xab, 0x5e, 0x69, 0xf2,
+			0x4c, 0x7f, 0x60, 0x70, 0xc8, 0xf8, 0x40, 0xc9, 0xab, 0xb4, 0xf6,
+			0x9f, 0xbf, 0xc8, 0xa7, 0xff, 0x51, 0x26, 0xfa, 0xee, 0xbb, 0xb5,
+			0x58, 0x05, 0xee, 0x9c, 0x1c, 0xf2, 0xce, 0x5a, 0x57, 0x26, 0x32,
+			0x87, 0xae, 0xc5, 0x78, 0x0f, 0x04, 0xec, 0x32, 0x4c, 0x35, 0x14,
+			0x12, 0x2c, 0xfc, 0x32, 0x31, 0xfc, 0x1a, 0x8b, 0x71, 0x8a, 0x62,
+			0x86, 0x37, 0x30, 0xa2, 0x70, 0x2b, 0xb7, 0x63, 0x66, 0x11, 0x6b,
+			0xed, 0x09, 0xe0, 0xfd, 0x5c, 0x6d, 0x84, 0xb6, 0xb0, 0xc1, 0xab,
+			0xaf, 0x24, 0x9d, 0x5d, 0xd0, 0xf7, 0xf5, 0xa7, 0xea,
+		},
+	},
+}
--- a/crypto/xchacha20poly1305/xchachapoly.go
+++ b/crypto/xchacha20poly1305/xchachapoly.go
@@ -0,0 +1,259 @@
+// Package xchacha20poly1305 creates an AEAD using hchacha, chacha, and poly1305
+// This allows for randomized nonces to be used in conjunction with chacha.
+package xchacha20poly1305
+
+import (
+	"crypto/cipher"
+	"encoding/binary"
+	"errors"
+	"fmt"
+
+	"golang.org/x/crypto/chacha20poly1305"
+)
+
+// Implements crypto.AEAD
+type xchacha20poly1305 struct {
+	key [KeySize]byte
+}
+
+const (
+	// KeySize is the size of the key used by this AEAD, in bytes.
+	KeySize = 32
+	// NonceSize is the size of the nonce used with this AEAD, in bytes.
+	NonceSize = 24
+	// TagSize is the size added from poly1305
+	TagSize = 16
+	// MaxPlaintextSize is the max size that can be passed into a single call of Seal
+	MaxPlaintextSize = (1 << 38) - 64
+	// MaxCiphertextSize is the max size that can be passed into a single call of Open,
+	// this differs from plaintext size due to the tag
+	MaxCiphertextSize = (1 << 38) - 48
+
+	// sigma are constants used in xchacha.
+	// Unrolled from a slice so that they can be inlined, as slices can't be constants.
+	sigma0 = uint32(0x61707865)
+	sigma1 = uint32(0x3320646e)
+	sigma2 = uint32(0x79622d32)
+	sigma3 = uint32(0x6b206574)
+)
+
+// New returns a new xchachapoly1305 AEAD
+func New(key []byte) (cipher.AEAD, error) {
+	if len(key) != KeySize {
+		return nil, errors.New("xchacha20poly1305: bad key length")
+	}
+	ret := new(xchacha20poly1305)
+	copy(ret.key[:], key)
+	return ret, nil
+}
+
+func (c *xchacha20poly1305) NonceSize() int {
+	return NonceSize
+}
+
+func (c *xchacha20poly1305) Overhead() int {
+	return TagSize
+}
+
+func (c *xchacha20poly1305) Seal(dst, nonce, plaintext, additionalData []byte) []byte {
+	if len(nonce) != NonceSize {
+		panic("xchacha20poly1305: bad nonce length passed to Seal")
+	}
+
+	if uint64(len(plaintext)) > MaxPlaintextSize {
+		panic("xchacha20poly1305: plaintext too large")
+	}
+
+	var subKey [KeySize]byte
+	var hNonce [16]byte
+	var subNonce [chacha20poly1305.NonceSize]byte
+	copy(hNonce[:], nonce[:16])
+
+	HChaCha20(&subKey, &hNonce, &c.key)
+
+	// This can't error because we always provide a correctly sized key
+	chacha20poly1305, _ := chacha20poly1305.New(subKey[:])
+
+	copy(subNonce[4:], nonce[16:])
+
+	return chacha20poly1305.Seal(dst, subNonce[:], plaintext, additionalData)
+}
+
+func (c *xchacha20poly1305) Open(dst, nonce, ciphertext, additionalData []byte) ([]byte, error) {
+	if len(nonce) != NonceSize {
+		return nil, fmt.Errorf("xchacha20poly1305: bad nonce length passed to Open")
+	}
+	if uint64(len(ciphertext)) > MaxCiphertextSize {
+		return nil, fmt.Errorf("xchacha20poly1305: ciphertext too large")
+	}
+	var subKey [KeySize]byte
+	var hNonce [16]byte
+	var subNonce [chacha20poly1305.NonceSize]byte
+	copy(hNonce[:], nonce[:16])
+
+	HChaCha20(&subKey, &hNonce, &c.key)
+
+	// This can't error because we always provide a correctly sized key
+	chacha20poly1305, _ := chacha20poly1305.New(subKey[:])
+
+	copy(subNonce[4:], nonce[16:])
+
+	return chacha20poly1305.Open(dst, subNonce[:], ciphertext, additionalData)
+}
+
+// HChaCha exported from
+// https://github.com/aead/chacha20/blob/8b13a72661dae6e9e5dea04f344f0dc95ea29547/chacha/chacha_generic.go#L194
+// TODO: Add support for the different assembly instructions used there.
+
+// The MIT License (MIT)
+
+// Copyright (c) 2016 Andreas Auernhammer
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// HChaCha20 generates 32 pseudo-random bytes from a 128 bit nonce and a 256 bit secret key.
+// It can be used as a key-derivation-function (KDF).
+func HChaCha20(out *[32]byte, nonce *[16]byte, key *[32]byte) { hChaCha20Generic(out, nonce, key) }
+
+func hChaCha20Generic(out *[32]byte, nonce *[16]byte, key *[32]byte) {
+	v00 := sigma0
+	v01 := sigma1
+	v02 := sigma2
+	v03 := sigma3
+	v04 := binary.LittleEndian.Uint32(key[0:])
+	v05 := binary.LittleEndian.Uint32(key[4:])
+	v06 := binary.LittleEndian.Uint32(key[8:])
+	v07 := binary.LittleEndian.Uint32(key[12:])
+	v08 := binary.LittleEndian.Uint32(key[16:])
+	v09 := binary.LittleEndian.Uint32(key[20:])
+	v10 := binary.LittleEndian.Uint32(key[24:])
+	v11 := binary.LittleEndian.Uint32(key[28:])
+	v12 := binary.LittleEndian.Uint32(nonce[0:])
+	v13 := binary.LittleEndian.Uint32(nonce[4:])
+	v14 := binary.LittleEndian.Uint32(nonce[8:])
+	v15 := binary.LittleEndian.Uint32(nonce[12:])
+
+	for i := 0; i < 20; i += 2 {
+		v00 += v04
+		v12 ^= v00
+		v12 = (v12 << 16) | (v12 >> 16)
+		v08 += v12
+		v04 ^= v08
+		v04 = (v04 << 12) | (v04 >> 20)
+		v00 += v04
+		v12 ^= v00
+		v12 = (v12 << 8) | (v12 >> 24)
+		v08 += v12
+		v04 ^= v08
+		v04 = (v04 << 7) | (v04 >> 25)
+		v01 += v05
+		v13 ^= v01
+		v13 = (v13 << 16) | (v13 >> 16)
+		v09 += v13
+		v05 ^= v09
+		v05 = (v05 << 12) | (v05 >> 20)
+		v01 += v05
+		v13 ^= v01
+		v13 = (v13 << 8) | (v13 >> 24)
+		v09 += v13
+		v05 ^= v09
+		v05 = (v05 << 7) | (v05 >> 25)
+		v02 += v06
+		v14 ^= v02
+		v14 = (v14 << 16) | (v14 >> 16)
+		v10 += v14
+		v06 ^= v10
+		v06 = (v06 << 12) | (v06 >> 20)
+		v02 += v06
+		v14 ^= v02
+		v14 = (v14 << 8) | (v14 >> 24)
+		v10 += v14
+		v06 ^= v10
+		v06 = (v06 << 7) | (v06 >> 25)
+		v03 += v07
+		v15 ^= v03
+		v15 = (v15 << 16) | (v15 >> 16)
+		v11 += v15
+		v07 ^= v11
+		v07 = (v07 << 12) | (v07 >> 20)
+		v03 += v07
+		v15 ^= v03
+		v15 = (v15 << 8) | (v15 >> 24)
+		v11 += v15
+		v07 ^= v11
+		v07 = (v07 << 7) | (v07 >> 25)
+		v00 += v05
+		v15 ^= v00
+		v15 = (v15 << 16) | (v15 >> 16)
+		v10 += v15
+		v05 ^= v10
+		v05 = (v05 << 12) | (v05 >> 20)
+		v00 += v05
+		v15 ^= v00
+		v15 = (v15 << 8) | (v15 >> 24)
+		v10 += v15
+		v05 ^= v10
+		v05 = (v05 << 7) | (v05 >> 25)
+		v01 += v06
+		v12 ^= v01
+		v12 = (v12 << 16) | (v12 >> 16)
+		v11 += v12
+		v06 ^= v11
+		v06 = (v06 << 12) | (v06 >> 20)
+		v01 += v06
+		v12 ^= v01
+		v12 = (v12 << 8) | (v12 >> 24)
+		v11 += v12
+		v06 ^= v11
+		v06 = (v06 << 7) | (v06 >> 25)
+		v02 += v07
+		v13 ^= v02
+		v13 = (v13 << 16) | (v13 >> 16)
+		v08 += v13
+		v07 ^= v08
+		v07 = (v07 << 12) | (v07 >> 20)
+		v02 += v07
+		v13 ^= v02
+		v13 = (v13 << 8) | (v13 >> 24)
+		v08 += v13
+		v07 ^= v08
+		v07 = (v07 << 7) | (v07 >> 25)
+		v03 += v04
+		v14 ^= v03
+		v14 = (v14 << 16) | (v14 >> 16)
+		v09 += v14
+		v04 ^= v09
+		v04 = (v04 << 12) | (v04 >> 20)
+		v03 += v04
+		v14 ^= v03
+		v14 = (v14 << 8) | (v14 >> 24)
+		v09 += v14
+		v04 ^= v09
+		v04 = (v04 << 7) | (v04 >> 25)
+	}
+
+	binary.LittleEndian.PutUint32(out[0:], v00)
+	binary.LittleEndian.PutUint32(out[4:], v01)
+	binary.LittleEndian.PutUint32(out[8:], v02)
+	binary.LittleEndian.PutUint32(out[12:], v03)
+	binary.LittleEndian.PutUint32(out[16:], v12)
+	binary.LittleEndian.PutUint32(out[20:], v13)
+	binary.LittleEndian.PutUint32(out[24:], v14)
+	binary.LittleEndian.PutUint32(out[28:], v15)
+}
--- a/Show More
+++ b/Show More