From c18470a5f1114f8c5469c311502050e88d2ca9bb Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 28 Sep 2021 16:47:35 -0400
Subject: [PATCH 01/57] e2e: use network size in load generator (#7019)

---
 test/e2e/runner/evidence.go |  4 ++--
 test/e2e/runner/load.go     | 37 ++++++++++++++++---------------------
 test/e2e/runner/main.go     | 30 ++++++++++++++++++++++--------
 3 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/test/e2e/runner/evidence.go b/test/e2e/runner/evidence.go
index e6c7c3f7ab..25c4a1cc44 100644
--- a/test/e2e/runner/evidence.go
+++ b/test/e2e/runner/evidence.go
@@ -28,11 +28,11 @@ const lightClientEvidenceRatio = 4
 // evidence and broadcasts it to a random node through the rpc endpoint `/broadcast_evidence`.
 // Evidence is random and can be a mixture of LightClientAttackEvidence and
 // DuplicateVoteEvidence.
-func InjectEvidence(ctx context.Context, testnet *e2e.Testnet, amount int) error {
+func InjectEvidence(ctx context.Context, r *rand.Rand, testnet *e2e.Testnet, amount int) error {
 	// select a random node
 	var targetNode *e2e.Node
 
-	for _, idx := range rand.Perm(len(testnet.Nodes)) {
+	for _, idx := range r.Perm(len(testnet.Nodes)) {
 		targetNode = testnet.Nodes[idx]
 
 		if targetNode.Mode == e2e.ModeSeed || targetNode.Mode == e2e.ModeLight {
diff --git a/test/e2e/runner/load.go b/test/e2e/runner/load.go
index 5e6e04f89e..f31b436dd4 100644
--- a/test/e2e/runner/load.go
+++ b/test/e2e/runner/load.go
@@ -14,15 +14,15 @@ import (
 
 // Load generates transactions against the network until the given context is
 // canceled.
-func Load(ctx context.Context, testnet *e2e.Testnet) error {
+func Load(ctx context.Context, r *rand.Rand, testnet *e2e.Testnet) error {
 	// Since transactions are executed across all nodes in the network, we need
 	// to reduce transaction load for larger networks to avoid using too much
 	// CPU. This gives high-throughput small networks and low-throughput large ones.
 	// This also limits the number of TCP connections, since each worker has
 	// a connection to all nodes.
-	concurrency := len(testnet.Nodes) * 8
-	if concurrency > 64 {
-		concurrency = 64
+	concurrency := len(testnet.Nodes) * 2
+	if concurrency > 32 {
+		concurrency = 32
 	}
 
 	chTx := make(chan types.Tx)
@@ -38,7 +38,7 @@ func Load(ctx context.Context, testnet *e2e.Testnet) error {
 
 	started := time.Now()
 
-	go loadGenerate(ctx, chTx, testnet.TxSize)
+	go loadGenerate(ctx, r, chTx, testnet.TxSize, len(testnet.Nodes))
 
 	for w := 0; w < concurrency; w++ {
 		go loadProcess(ctx, testnet, chTx, chSuccess)
@@ -85,7 +85,7 @@ func Load(ctx context.Context, testnet *e2e.Testnet) error {
 // generation is primarily the result of backpressure from the
 // broadcast transaction, though there is still some timer-based
 // limiting.
-func loadGenerate(ctx context.Context, chTx chan<- types.Tx, size int64) {
+func loadGenerate(ctx context.Context, r *rand.Rand, chTx chan<- types.Tx, txSize int64, networkSize int) {
 	timer := time.NewTimer(0)
 	defer timer.Stop()
 	defer close(chTx)
@@ -101,8 +101,8 @@ func loadGenerate(ctx context.Context, chTx chan<- types.Tx, size int64) {
 		// This gives a reasonable load without putting too much data in the app.
 		id := rand.Int63() % 100 // nolint: gosec
 
-		bz := make([]byte, size)
-		_, err := rand.Read(bz) // nolint: gosec
+		bz := make([]byte, txSize)
+		_, err := r.Read(bz)
 		if err != nil {
 			panic(fmt.Sprintf("Failed to read random bytes: %v", err))
 		}
@@ -114,30 +114,25 @@ func loadGenerate(ctx context.Context, chTx chan<- types.Tx, size int64) {
 		case chTx <- tx:
 			// sleep for a bit before sending the
 			// next transaction.
-			timer.Reset(loadGenerateWaitTime(size))
+			timer.Reset(loadGenerateWaitTime(r, networkSize))
 		}
 
 	}
 }
 
-func loadGenerateWaitTime(size int64) time.Duration {
+func loadGenerateWaitTime(r *rand.Rand, size int) time.Duration {
 	const (
-		min = int64(10 * time.Millisecond)
-		max = int64(100 * time.Millisecond)
+		min = int64(250 * time.Millisecond)
+		max = int64(time.Second)
 	)
 
 	var (
-		baseJitter = rand.Int63n(max-min+1) + min // nolint: gosec
-		sizeFactor = size * int64(time.Millisecond)
-		sizeJitter = rand.Int63n(sizeFactor-min+1) + min // nolint: gosec
-		waitTime   = time.Duration(baseJitter + sizeJitter)
+		baseJitter = r.Int63n(max-min+1) + min
+		sizeFactor = int64(size) * min
+		sizeJitter = r.Int63n(sizeFactor-min+1) + min
 	)
 
-	if size == 1 {
-		return waitTime / 2
-	}
-
-	return waitTime
+	return time.Duration(baseJitter + sizeJitter)
 }
 
 // loadProcess processes transactions
diff --git a/test/e2e/runner/main.go b/test/e2e/runner/main.go
index 194e4c6e4a..fb6ce4a8cb 100644
--- a/test/e2e/runner/main.go
+++ b/test/e2e/runner/main.go
@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"fmt"
+	"math/rand"
 	"os"
 	"strconv"
 	"time"
@@ -13,9 +14,9 @@ import (
 	e2e "github.com/tendermint/tendermint/test/e2e/pkg"
 )
 
-var (
-	logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
-)
+const randomSeed = 2308084734268
+
+var logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
 
 func main() {
 	NewCLI().Run()
@@ -67,6 +68,8 @@ func NewCLI() *CLI {
 				return err
 			}
 
+			r := rand.New(rand.NewSource(randomSeed)) // nolint: gosec
+
 			chLoadResult := make(chan error)
 			ctx, cancel := context.WithCancel(cmd.Context())
 			defer cancel()
@@ -74,7 +77,7 @@ func NewCLI() *CLI {
 			lctx, loadCancel := context.WithCancel(ctx)
 			defer loadCancel()
 			go func() {
-				chLoadResult <- Load(lctx, cli.testnet)
+				chLoadResult <- Load(lctx, r, cli.testnet)
 			}()
 			startAt := time.Now()
 			if err = Start(ctx, cli.testnet); err != nil {
@@ -95,7 +98,7 @@ func NewCLI() *CLI {
 			}
 
 			if cli.testnet.Evidence > 0 {
-				if err = InjectEvidence(ctx, cli.testnet, cli.testnet.Evidence); err != nil {
+				if err = InjectEvidence(ctx, r, cli.testnet, cli.testnet.Evidence); err != nil {
 					return err
 				}
 				if err = Wait(ctx, cli.testnet, 5); err != nil { // ensure chain progress
@@ -212,7 +215,11 @@ func NewCLI() *CLI {
 		Use:   "load",
 		Short: "Generates transaction load until the command is canceled",
 		RunE: func(cmd *cobra.Command, args []string) (err error) {
-			return Load(context.Background(), cli.testnet)
+			return Load(
+				cmd.Context(),
+				rand.New(rand.NewSource(randomSeed)), // nolint: gosec
+				cli.testnet,
+			)
 		},
 	})
 
@@ -230,7 +237,12 @@ func NewCLI() *CLI {
 				}
 			}
 
-			return InjectEvidence(cmd.Context(), cli.testnet, amount)
+			return InjectEvidence(
+				cmd.Context(),
+				rand.New(rand.NewSource(randomSeed)), // nolint: gosec
+				cli.testnet,
+				amount,
+			)
 		},
 	})
 
@@ -302,10 +314,12 @@ Does not run any perbutations.
 			ctx, cancel := context.WithCancel(cmd.Context())
 			defer cancel()
 
+			r := rand.New(rand.NewSource(randomSeed)) // nolint: gosec
+
 			lctx, loadCancel := context.WithCancel(ctx)
 			defer loadCancel()
 			go func() {
-				err := Load(lctx, cli.testnet)
+				err := Load(lctx, r, cli.testnet)
 				chLoadResult <- err
 			}()
 

From b1dfbb8bc37e1a90551560e8b09078b49ef133c1 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 28 Sep 2021 17:04:37 -0400
Subject: [PATCH 02/57] e2e: generator ensure p2p modes (#7021)

---
 test/e2e/generator/generate.go      | 16 ++++++++---
 test/e2e/generator/generate_test.go | 41 +++++++++++++++++++++++++++++
 test/e2e/generator/main.go          |  3 +--
 test/e2e/tests/app_test.go          | 12 ++++++---
 4 files changed, 63 insertions(+), 9 deletions(-)

diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index 81c1be7eff..deffb533a7 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -81,8 +81,7 @@ func Generate(r *rand.Rand, opts Options) ([]e2e.Manifest, error) {
 		}()
 
 		testnetCombinations["p2p"] = []interface{}{opts.P2P}
-
-	default:
+	case MixedP2PMode:
 		testnetCombinations["p2p"] = []interface{}{NewP2PMode, LegacyP2PMode, HybridP2PMode}
 	}
 
@@ -332,9 +331,20 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 	// lastly, set up the light clients
 	for i := 1; i <= numLightClients; i++ {
 		startAt := manifest.InitialHeight + 5
-		manifest.Nodes[fmt.Sprintf("light%02d", i)] = generateLightNode(
+
+		node := generateLightNode(
 			r, startAt+(5*int64(i)), lightProviders,
 		)
+
+		switch p2pMode {
+		case LegacyP2PMode:
+			node.UseLegacyP2P = true
+		case HybridP2PMode:
+			node.UseLegacyP2P = r.Float64() < legacyP2PFactor
+		}
+
+		manifest.Nodes[fmt.Sprintf("light%02d", i)] = node
+
 	}
 
 	return manifest, nil
diff --git a/test/e2e/generator/generate_test.go b/test/e2e/generator/generate_test.go
index b816ba5771..c38b6b20bc 100644
--- a/test/e2e/generator/generate_test.go
+++ b/test/e2e/generator/generate_test.go
@@ -47,6 +47,9 @@ func TestGenerator(t *testing.T) {
 		require.NoError(t, err)
 		require.True(t, len(manifests) >= 16, "insufficient combinations: %d", len(manifests))
 
+		// failures map to the test cases that you'd see locally.
+		e2e.SortManifests(manifests, false /* ascending */)
+
 		for idx, m := range manifests {
 			t.Run(fmt.Sprintf("Case%04d", idx), func(t *testing.T) {
 				require.True(t, len(m.Nodes) > 1)
@@ -67,4 +70,42 @@ func TestGenerator(t *testing.T) {
 			})
 		}
 	})
+	t.Run("UnmixedP2P", func(t *testing.T) {
+		t.Run("New", func(t *testing.T) {
+			manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), Options{P2P: NewP2PMode})
+			require.NoError(t, err)
+			require.True(t, len(manifests) >= 16, "insufficient combinations: %d", len(manifests))
+
+			// failures map to the test cases that you'd see locally.
+			e2e.SortManifests(manifests, false /* ascending */)
+
+			for idx, m := range manifests {
+				t.Run(fmt.Sprintf("Case%04d", idx), func(t *testing.T) {
+					for name, node := range m.Nodes {
+						t.Run(name, func(t *testing.T) {
+							require.False(t, node.UseLegacyP2P)
+						})
+					}
+				})
+			}
+		})
+		t.Run("Legacy", func(t *testing.T) {
+			manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), Options{P2P: LegacyP2PMode})
+			require.NoError(t, err)
+			require.True(t, len(manifests) >= 16, "insufficient combinations: %d", len(manifests))
+
+			// failures map to the test cases that you'd see locally.
+			e2e.SortManifests(manifests, false /* ascending */)
+
+			for idx, m := range manifests {
+				t.Run(fmt.Sprintf("Case%04d", idx), func(t *testing.T) {
+					for name, node := range m.Nodes {
+						t.Run(name, func(t *testing.T) {
+							require.True(t, node.UseLegacyP2P)
+						})
+					}
+				})
+			}
+		})
+	})
 }
diff --git a/test/e2e/generator/main.go b/test/e2e/generator/main.go
index 6e39be8200..4668f6a8f7 100644
--- a/test/e2e/generator/main.go
+++ b/test/e2e/generator/main.go
@@ -38,7 +38,6 @@ func NewCLI() *CLI {
 		SilenceUsage:  true,
 		SilenceErrors: true, // we'll output them ourselves in Run()
 		RunE: func(cmd *cobra.Command, args []string) error {
-			var opts Options
 			var err error
 
 			p2pMode, err := cmd.Flags().GetString("p2p")
@@ -48,7 +47,7 @@ func NewCLI() *CLI {
 
 			switch mode := P2PMode(p2pMode); mode {
 			case NewP2PMode, LegacyP2PMode, HybridP2PMode, MixedP2PMode:
-				opts.P2P = mode
+				cli.opts.P2P = mode
 			default:
 				return fmt.Errorf("p2p mode must be either new, legacy, hybrid or mixed got %s", p2pMode)
 			}
diff --git a/test/e2e/tests/app_test.go b/test/e2e/tests/app_test.go
index afd4d2d52a..ab6f9739e4 100644
--- a/test/e2e/tests/app_test.go
+++ b/test/e2e/tests/app_test.go
@@ -44,13 +44,17 @@ func TestApp_Hash(t *testing.T) {
 		require.NoError(t, err)
 		require.NotEmpty(t, info.Response.LastBlockAppHash, "expected app to return app hash")
 
-		block, err := client.Block(ctx, &info.Response.LastBlockHeight)
+		status, err := client.Status(ctx)
 		require.NoError(t, err)
-		require.EqualValues(t, info.Response.LastBlockAppHash, block.Block.AppHash.Bytes(),
-			"app hash does not match last block's app hash")
 
-		status, err := client.Status(ctx)
+		block, err := client.Block(ctx, &info.Response.LastBlockHeight)
 		require.NoError(t, err)
+
+		if info.Response.LastBlockHeight == block.Block.Height {
+			require.EqualValues(t, info.Response.LastBlockAppHash, block.Block.AppHash.Bytes(),
+				"app hash does not match last block's app hash")
+		}
+
 		require.True(t, status.SyncInfo.LatestBlockHeight >= info.Response.LastBlockHeight,
 			"status out of sync with application")
 	})

From 8758078786f5477b249a2e3b41f4404ff199a512 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Wed, 29 Sep 2021 11:19:34 -0400
Subject: [PATCH 03/57] consensus: avoid unbuffered channel in state test
 (#7025)

---
 internal/consensus/state.go      |  6 +++++-
 internal/consensus/state_test.go | 17 ++++-------------
 2 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/internal/consensus/state.go b/internal/consensus/state.go
index 46bacf5cc8..42900a7d48 100644
--- a/internal/consensus/state.go
+++ b/internal/consensus/state.go
@@ -241,8 +241,12 @@ func (cs *State) GetLastHeight() int64 {
 // GetRoundState returns a shallow copy of the internal consensus state.
 func (cs *State) GetRoundState() *cstypes.RoundState {
 	cs.mtx.RLock()
+	defer cs.mtx.RUnlock()
+
+	// NOTE: this might be dodgy, as RoundState itself isn't thread
+	// safe as it contains a number of pointers and is explicitly
+	// not thread safe.
 	rs := cs.RoundState // copy
-	cs.mtx.RUnlock()
 	return &rs
 }
 
diff --git a/internal/consensus/state_test.go b/internal/consensus/state_test.go
index b3b7c81a38..9b8f68a5ee 100644
--- a/internal/consensus/state_test.go
+++ b/internal/consensus/state_test.go
@@ -331,7 +331,7 @@ func TestStateFullRound1(t *testing.T) {
 		t.Error(err)
 	}
 
-	voteCh := subscribeUnBuffered(cs.eventBus, types.EventQueryVote)
+	voteCh := subscribe(cs.eventBus, types.EventQueryVote)
 	propCh := subscribe(cs.eventBus, types.EventQueryCompleteProposal)
 	newRoundCh := subscribe(cs.eventBus, types.EventQueryNewRound)
 
@@ -361,7 +361,7 @@ func TestStateFullRoundNil(t *testing.T) {
 	cs, vss := randState(config, 1)
 	height, round := cs.Height, cs.Round
 
-	voteCh := subscribeUnBuffered(cs.eventBus, types.EventQueryVote)
+	voteCh := subscribe(cs.eventBus, types.EventQueryVote)
 
 	cs.enterPrevote(height, round)
 	cs.startRoutines(4)
@@ -382,7 +382,7 @@ func TestStateFullRound2(t *testing.T) {
 	vs2 := vss[1]
 	height, round := cs1.Height, cs1.Round
 
-	voteCh := subscribeUnBuffered(cs1.eventBus, types.EventQueryVote)
+	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)
 	newBlockCh := subscribe(cs1.eventBus, types.EventQueryNewBlock)
 
 	// start round and wait for propose and prevote
@@ -428,7 +428,7 @@ func TestStateLockNoPOL(t *testing.T) {
 
 	timeoutProposeCh := subscribe(cs1.eventBus, types.EventQueryTimeoutPropose)
 	timeoutWaitCh := subscribe(cs1.eventBus, types.EventQueryTimeoutWait)
-	voteCh := subscribeUnBuffered(cs1.eventBus, types.EventQueryVote)
+	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	newRoundCh := subscribe(cs1.eventBus, types.EventQueryNewRound)
 
@@ -1971,12 +1971,3 @@ func subscribe(eventBus *types.EventBus, q tmpubsub.Query) <-chan tmpubsub.Messa
 	}
 	return sub.Out()
 }
-
-// subscribe subscribes test client to the given query and returns a channel with cap = 0.
-func subscribeUnBuffered(eventBus *types.EventBus, q tmpubsub.Query) <-chan tmpubsub.Message {
-	sub, err := eventBus.SubscribeUnbuffered(context.Background(), testSubscriber, q)
-	if err != nil {
-		panic(fmt.Sprintf("failed to subscribe %s to %v", testSubscriber, q))
-	}
-	return sub.Out()
-}

From 962caeae65eed0796e21fdf0fbb2109096ea5a2f Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Wed, 29 Sep 2021 08:38:52 -0700
Subject: [PATCH 04/57] Make doc site index default to the latest release
 (#7023)

Fix the order of lines in docs/versions so that v0.34 is last (the current release).

Related changes:

- Update docs/DOCS_README.md to reflect the current state of how we publish the site.
- Fix the build-docs target in Makefile to not perturb the package-lock.json during the build.
- Fix the Makefile rule to not clobber package-lock.json.
---
 CONTRIBUTING.md     |  9 +++++++++
 Makefile            |  6 +++---
 docs/DOCS_README.md | 24 +++++++++++++++++-------
 docs/versions       |  2 +-
 4 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 23bfafcdf9..33b8cf6a78 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -249,6 +249,7 @@ The author of the original pull request is responsible for solving the conflicts
 merging the pull request.
 
 #### Creating a backport branch
+
 If this is the first release candidate for a major release, you get to have the honor of creating
 the backport branch!
 
@@ -334,6 +335,14 @@ If there were no release candidates, begin by creating a backport branch, as des
    - `git tag -a v0.35.0 -m 'Release v0.35.0'`
    - `git push origin v0.35.0`
 7. Make sure that `master` is updated with the latest `CHANGELOG.md`, `CHANGELOG_PENDING.md`, and `UPGRADING.md`.
+8. Add the release to the documentation site generator config (see
+   [DOCS_README.md](./docs/DOCS_README.md) for more details). In summary:
+   - Start on branch `master`.
+   - Add a new line at the bottom of [`docs/versions`](./docs/versions) to
+     ensure the newest release is the default for the landing page.
+   - Add a new entry to `themeConfig.versions` in
+     [`docs/.vuepress/config.js`](./docs/.vuepress/config.js) to include the
+	 release in the dropdown versions menu.
 
 #### Minor release (point releases)
 
diff --git a/Makefile b/Makefile
index a509f3a265..c9b6951f4d 100644
--- a/Makefile
+++ b/Makefile
@@ -131,11 +131,11 @@ generate_test_cert:
 	# generate server cerificate
 	@certstrap request-cert -cn server -ip 127.0.0.1
 	# self-sign server cerificate with rootCA
-	@certstrap sign server --CA "root CA" 
+	@certstrap sign server --CA "root CA"
 	# generate client cerificate
 	@certstrap request-cert -cn client -ip 127.0.0.1
 	# self-sign client cerificate with rootCA
-	@certstrap sign client --CA "root CA" 
+	@certstrap sign client --CA "root CA"
 .PHONY: generate_test_cert
 
 ###############################################################################
@@ -214,7 +214,7 @@ DESTINATION = ./index.html.md
 build-docs:
 	@cd docs && \
 	while read -r branch path_prefix; do \
-		(git checkout $${branch} && npm install && VUEPRESS_BASE="/$${path_prefix}/" npm run build) ; \
+		(git checkout $${branch} && npm ci && VUEPRESS_BASE="/$${path_prefix}/" npm run build) ; \
 		mkdir -p ~/output/$${path_prefix} ; \
 		cp -r .vuepress/dist/* ~/output/$${path_prefix}/ ; \
 		cp ~/output/$${path_prefix}/index.html ~/output ; \
diff --git a/docs/DOCS_README.md b/docs/DOCS_README.md
index 04883e462a..c1ab1580ab 100644
--- a/docs/DOCS_README.md
+++ b/docs/DOCS_README.md
@@ -2,17 +2,27 @@
 
 The documentation for Tendermint Core is hosted at:
 
-- <https://docs.tendermint.com/master/>
+- <https://docs.tendermint.com/>
 
-built from the files in this (`/docs`) directory for
-[master](https://github.com/tendermint/tendermint/tree/master/docs) respectively.
+built from the files in this [`docs` directory for `master`](https://github.com/tendermint/tendermint/tree/master/docs)
+and other supported release branches.
 
 ## How It Works
 
-There is a CircleCI job listening for changes in the `/docs` directory, on both
-the `master` branch. Any updates to files in this directory
-on those branches will automatically trigger a website deployment. Under the hood,
-the private website repository has a `make build-docs` target consumed by a CircleCI job in that repo.
+There is a [GitHub Actions workflow](https://github.com/tendermint/docs/actions/workflows/deployment.yml)
+in the `tendermint/docs` repository that clones and builds the documentation
+site from the contents of this `docs` directory, for `master` and for each
+supported release branch. Under the hood, this workflow runs `make build-docs`
+from the [Makefile](../Makefile#L214).
+
+The list of supported versions are defined in [`config.js`](./.vuepress/config.js),
+which defines the UI menu on the documentation site, and also in
+[`docs/versions`](./versions), which determines which branches are built.
+
+The last entry in the `docs/versions` file determines which version is linked
+by default from the generated `index.html`. This should generally be the most
+recent release, rather than `master`, so that new users are not confused by
+documentation for unreleased features.
 
 ## README
 
diff --git a/docs/versions b/docs/versions
index 7ae4a265a4..c88a614bd9 100644
--- a/docs/versions
+++ b/docs/versions
@@ -1,4 +1,4 @@
+master                  master
 v0.32.x                 v0.32
 v0.33.x                 v0.33
 v0.34.x                 v0.34
-master                  master

From 23fe6fd2f9820c28ce397443e83e4d500ba45900 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Wed, 29 Sep 2021 12:38:27 -0400
Subject: [PATCH 05/57] statesync: ensure test network properly configured
 (#7026)

This test reliably gets hung up on network configuration, (which may
be a real issue,) but it's network setup is handcranked and we should
ensure that the test focuses on it's core assertions and doesn't fail for
test architecture reasons.
---
 internal/statesync/dispatcher.go   | 13 +++++++++++++
 internal/statesync/reactor.go      |  8 +++++---
 internal/statesync/reactor_test.go | 24 +++++++++++++++++++-----
 3 files changed, 37 insertions(+), 8 deletions(-)

diff --git a/internal/statesync/dispatcher.go b/internal/statesync/dispatcher.go
index 2ff93a023c..844cb5e323 100644
--- a/internal/statesync/dispatcher.go
+++ b/internal/statesync/dispatcher.go
@@ -297,3 +297,16 @@ func (l *peerList) All() []types.NodeID {
 	defer l.mtx.Unlock()
 	return l.peers
 }
+
+func (l *peerList) Contains(id types.NodeID) bool {
+	l.mtx.Lock()
+	defer l.mtx.Unlock()
+
+	for _, p := range l.peers {
+		if id == p {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index 0d8ab7f4ca..a20c8ca41a 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -254,11 +254,11 @@ func (r *Reactor) OnStop() {
 	// Wait for all p2p Channels to be closed before returning. This ensures we
 	// can easily reason about synchronization of all p2p Channels and ensure no
 	// panics will occur.
+	<-r.peerUpdates.Done()
 	<-r.snapshotCh.Done()
 	<-r.chunkCh.Done()
 	<-r.blockCh.Done()
 	<-r.paramsCh.Done()
-	<-r.peerUpdates.Done()
 }
 
 // Sync runs a state sync, fetching snapshots and providing chunks to the
@@ -1013,9 +1013,11 @@ func (r *Reactor) waitForEnoughPeers(ctx context.Context, numPeers int) error {
 		iter++
 		select {
 		case <-ctx.Done():
-			return fmt.Errorf("operation canceled while waiting for peers after %s", time.Since(startAt))
+			return fmt.Errorf("operation canceled while waiting for peers after %.2fs [%d/%d]",
+				time.Since(startAt).Seconds(), r.peers.Len(), numPeers)
 		case <-r.closeCh:
-			return fmt.Errorf("shutdown while waiting for peers after %s", time.Since(startAt))
+			return fmt.Errorf("shutdown while waiting for peers after %.2fs [%d/%d]",
+				time.Since(startAt).Seconds(), r.peers.Len(), numPeers)
 		case <-t.C:
 			continue
 		case <-logT.C:
diff --git a/internal/statesync/reactor_test.go b/internal/statesync/reactor_test.go
index 7bcfe39aff..b90e5fd789 100644
--- a/internal/statesync/reactor_test.go
+++ b/internal/statesync/reactor_test.go
@@ -525,25 +525,39 @@ func TestReactor_StateProviderP2P(t *testing.T) {
 	rts.reactor.cfg.UseP2P = true
 	rts.reactor.cfg.TrustHeight = 1
 	rts.reactor.cfg.TrustHash = fmt.Sprintf("%X", chain[1].Hash())
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+
+	for _, p := range []types.NodeID{peerA, peerB} {
+		if !rts.reactor.peers.Contains(p) {
+			rts.reactor.peers.Append(p)
+		}
+	}
+	require.True(t, rts.reactor.peers.Len() >= 2, "peer network not configured")
+
+	bctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	ictx, cancel := context.WithTimeout(bctx, time.Second)
 	defer cancel()
 
 	rts.reactor.mtx.Lock()
-	err := rts.reactor.initStateProvider(ctx, factory.DefaultTestChainID, 1)
+	err := rts.reactor.initStateProvider(ictx, factory.DefaultTestChainID, 1)
 	rts.reactor.mtx.Unlock()
 	require.NoError(t, err)
 	rts.reactor.syncer.stateProvider = rts.reactor.stateProvider
 
-	appHash, err := rts.reactor.stateProvider.AppHash(ctx, 5)
+	actx, cancel := context.WithTimeout(bctx, 10*time.Second)
+	defer cancel()
+
+	appHash, err := rts.reactor.stateProvider.AppHash(actx, 5)
 	require.NoError(t, err)
 	require.Len(t, appHash, 32)
 
-	state, err := rts.reactor.stateProvider.State(ctx, 5)
+	state, err := rts.reactor.stateProvider.State(actx, 5)
 	require.NoError(t, err)
 	require.Equal(t, appHash, state.AppHash)
 	require.Equal(t, types.DefaultConsensusParams(), &state.ConsensusParams)
 
-	commit, err := rts.reactor.stateProvider.Commit(ctx, 5)
+	commit, err := rts.reactor.stateProvider.Commit(actx, 5)
 	require.NoError(t, err)
 	require.Equal(t, commit.BlockID, state.LastBlockID)
 

From c9d92f5f19f75500c6a4b73b8ec04fe9dd8abb0d Mon Sep 17 00:00:00 2001
From: Tess Rinearson <tess.rinearson@gmail.com>
Date: Wed, 29 Sep 2021 22:02:28 +0200
Subject: [PATCH 06/57] .github: remove tessr and bez from codeowners (#7028)

---
 .github/CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 7993419e80..b48354f014 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -7,4 +7,4 @@
 # global owners are only requested if there isn't a more specific
 # codeowner specified below. For this reason, the global codeowners
 # are often repeated in package-level definitions.
-*       @alexanderbez @ebuchman @cmwaters @tessr @tychoish @williambanfield @creachadair
+*      @ebuchman @cmwaters @tychoish @williambanfield @creachadair

From 6a0d9c832a400468f4884423f53e8630357b86b4 Mon Sep 17 00:00:00 2001
From: William Banfield <4561443+williambanfield@users.noreply.github.com>
Date: Thu, 30 Sep 2021 12:19:18 -0400
Subject: [PATCH 07/57] blocksync: fix shutdown deadlock issue (#7030)

When shutting down blocksync, it is observed that the process can hang completely. A dump of running goroutines reveals that this is due to goroutines not listening on the correct shutdown signal. Namely, the `poolRoutine` goroutine does not wait on `pool.Quit`. The `poolRoutine` does not receive any other shutdown signal during `OnStop` becuase it must stop before the `r.closeCh` is closed. Currently the `poolRoutine` listens in the `closeCh` which will not close until the `poolRoutine` stops and calls `poolWG.Done()`.

This change also puts the `requestRoutine()` in the `OnStart` method to make it more visible since it does not rely on anything that is spawned in the `poolRoutine`.

```
goroutine 183 [semacquire]:
sync.runtime_Semacquire(0xc0000d3bd8)
        runtime/sema.go:56 +0x45
sync.(*WaitGroup).Wait(0xc0000d3bd0)
        sync/waitgroup.go:130 +0x65
github.com/tendermint/tendermint/internal/blocksync/v0.(*Reactor).OnStop(0xc0000d3a00)
        github.com/tendermint/tendermint/internal/blocksync/v0/reactor.go:193 +0x47
github.com/tendermint/tendermint/libs/service.(*BaseService).Stop(0xc0000d3a00, 0x0, 0x0)
        github.com/tendermint/tendermint/libs/service/service.go:171 +0x323
github.com/tendermint/tendermint/node.(*nodeImpl).OnStop(0xc00052c000)
        github.com/tendermint/tendermint/node/node.go:758 +0xc62
github.com/tendermint/tendermint/libs/service.(*BaseService).Stop(0xc00052c000, 0x0, 0x0)
        github.com/tendermint/tendermint/libs/service/service.go:171 +0x323
github.com/tendermint/tendermint/cmd/tendermint/commands.NewRunNodeCmd.func1.1()
        github.com/tendermint/tendermint/cmd/tendermint/commands/run_node.go:143 +0x62
github.com/tendermint/tendermint/libs/os.TrapSignal.func1(0xc000df6d20, 0x7f04a68da900, 0xc0004a8930, 0xc0005a72d8)
        github.com/tendermint/tendermint/libs/os/os.go:26 +0x102
created by github.com/tendermint/tendermint/libs/os.TrapSignal
        github.com/tendermint/tendermint/libs/os/os.go:22 +0xe6


goroutine 161 [select]:
github.com/tendermint/tendermint/internal/blocksync/v0.(*Reactor).poolRoutine(0xc0000d3a00, 0x0)
        github.com/tendermint/tendermint/internal/blocksync/v0/reactor.go:464 +0x2b3
created by github.com/tendermint/tendermint/internal/blocksync/v0.(*Reactor).OnStart
        github.com/tendermint/tendermint/internal/blocksync/v0/reactor.go:174 +0xf1

goroutine 162 [select]:
github.com/tendermint/tendermint/internal/blocksync/v0.(*Reactor).processBlockSyncCh(0xc0000d3a00)
        github.com/tendermint/tendermint/internal/blocksync/v0/reactor.go:310 +0x151
created by github.com/tendermint/tendermint/internal/blocksync/v0.(*Reactor).OnStart
        github.com/tendermint/tendermint/internal/blocksync/v0/reactor.go:177 +0x54

goroutine 163 [select]:
github.com/tendermint/tendermint/internal/blocksync/v0.(*Reactor).processPeerUpdates(0xc0000d3a00)
        github.com/tendermint/tendermint/internal/blocksync/v0/reactor.go:363 +0x12b
created by github.com/tendermint/tendermint/internal/blocksync/v0.(*Reactor).OnStart
        github.com/tendermint/tendermint/internal/blocksync/v0/reactor.go:178 +0x76
```
---
 internal/blocksync/v0/reactor.go | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/internal/blocksync/v0/reactor.go b/internal/blocksync/v0/reactor.go
index 286df0ef07..552dcbda5d 100644
--- a/internal/blocksync/v0/reactor.go
+++ b/internal/blocksync/v0/reactor.go
@@ -169,6 +169,8 @@ func (r *Reactor) OnStart() error {
 		if err := r.pool.Start(); err != nil {
 			return err
 		}
+		r.poolWG.Add(1)
+		go r.requestRoutine()
 
 		r.poolWG.Add(1)
 		go r.poolRoutine(false)
@@ -384,6 +386,9 @@ func (r *Reactor) SwitchToBlockSync(state sm.State) error {
 
 	r.syncStartTime = time.Now()
 
+	r.poolWG.Add(1)
+	go r.requestRoutine()
+
 	r.poolWG.Add(1)
 	go r.poolRoutine(true)
 
@@ -394,7 +399,6 @@ func (r *Reactor) requestRoutine() {
 	statusUpdateTicker := time.NewTicker(statusUpdateIntervalSeconds * time.Second)
 	defer statusUpdateTicker.Stop()
 
-	r.poolWG.Add(1)
 	defer r.poolWG.Done()
 
 	for {
@@ -455,8 +459,6 @@ func (r *Reactor) poolRoutine(stateSynced bool) {
 	defer trySyncTicker.Stop()
 	defer switchToConsensusTicker.Stop()
 
-	go r.requestRoutine()
-
 	defer r.poolWG.Done()
 
 FOR_LOOP:
@@ -605,6 +607,8 @@ FOR_LOOP:
 
 		case <-r.closeCh:
 			break FOR_LOOP
+		case <-r.pool.Quit():
+			break FOR_LOOP
 		}
 	}
 }

From 77052370cce980fa378d7acc414120faf80ab573 Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Thu, 30 Sep 2021 10:13:32 -0700
Subject: [PATCH 08/57] Update default config template to match mapstructure
 keys. (#7036)

Fix a couple of cases where we updated the keys in the config reader, but
forgot to update some of their uses in the default template.

Fixes #7031.
---
 config/toml.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/config/toml.go b/config/toml.go
index 986ff1c2a6..e4c86c9f46 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -164,10 +164,10 @@ laddr = "{{ .PrivValidator.ListenAddr }}"
 client-certificate-file = "{{ js .PrivValidator.ClientCertificate }}"
 
 # Client key generated while creating certificates for secure connection
-validator-client-key-file = "{{ js .PrivValidator.ClientKey }}"
+client-key-file = "{{ js .PrivValidator.ClientKey }}"
 
 # Path to the Root Certificate Authority used to sign both client and server certificates
-certificate-authority = "{{ js .PrivValidator.RootCA }}"
+root-ca-file = "{{ js .PrivValidator.RootCA }}"
 
 
 #######################################################################
@@ -447,8 +447,8 @@ rpc-servers = "{{ StringsJoin .StateSync.RPCServers "," }}"
 trust-height = {{ .StateSync.TrustHeight }}
 trust-hash = "{{ .StateSync.TrustHash }}"
 
-# The trust period should be set so that Tendermint can detect and gossip misbehavior before 
-# it is considered expired. For chains based on the Cosmos SDK, one day less than the unbonding 
+# The trust period should be set so that Tendermint can detect and gossip misbehavior before
+# it is considered expired. For chains based on the Cosmos SDK, one day less than the unbonding
 # period should suffice.
 trust-period = "{{ .StateSync.TrustPeriod }}"
 

From bdd815ebc9209e11947353a12557558e81f4e5d5 Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Thu, 30 Sep 2021 10:53:05 -0700
Subject: [PATCH 09/57] Align atomic struct field for compatibility in 32-bit
 ABIs. (#7037)

The layout of struct fields means that interior fields may not be properly
aligned for 64-bit access.

Fixes #7000.
---
 internal/p2p/conn/connection.go | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/internal/p2p/conn/connection.go b/internal/p2p/conn/connection.go
index dc5bacc397..339ad74697 100644
--- a/internal/p2p/conn/connection.go
+++ b/internal/p2p/conn/connection.go
@@ -751,13 +751,18 @@ func (chDesc ChannelDescriptor) FillDefaults() (filled ChannelDescriptor) {
 // TODO: lowercase.
 // NOTE: not goroutine-safe.
 type Channel struct {
+	// Exponential moving average.
+	// This field must be accessed atomically.
+	// It is first in the struct to ensure correct alignment.
+	// See https://github.com/tendermint/tendermint/issues/7000.
+	recentlySent int64
+
 	conn          *MConnection
 	desc          ChannelDescriptor
 	sendQueue     chan []byte
 	sendQueueSize int32 // atomic.
 	recving       []byte
 	sending       []byte
-	recentlySent  int64 // exponential moving average
 
 	maxPacketMsgPayloadSize int
 

From 177850a2c95408d967c9f7c71ef463cf4ed61df9 Mon Sep 17 00:00:00 2001
From: William Banfield <4561443+williambanfield@users.noreply.github.com>
Date: Thu, 30 Sep 2021 15:19:10 -0400
Subject: [PATCH 10/57] statesync: remove deadlock on init fail (#7029)

When statesync is stopped during shutdown, it has the possibility of deadlocking. A dump of goroutines reveals that this is related to the peerUpdates channel not returning anything on its `Done()` channel when `OnStop` is called. As this is occuring, `processPeerUpdate` is attempting to acquire the reactor lock. It appears that this lock can never be acquired. I looked for the places where the lock may remain locked accidentally and cleaned them up in hopes to eradicate the issue. Dumps of the relevant goroutines may be found below. Note that the line numbers below are relative to the code in the `v0.35.0-rc1` tag.

```
goroutine 36 [chan receive]:
github.com/tendermint/tendermint/internal/statesync.(*Reactor).OnStop(0xc00058f200)
        github.com/tendermint/tendermint/internal/statesync/reactor.go:243 +0x117
github.com/tendermint/tendermint/libs/service.(*BaseService).Stop(0xc00058f200, 0x0, 0x0)
        github.com/tendermint/tendermint/libs/service/service.go:171 +0x323
github.com/tendermint/tendermint/node.(*nodeImpl).OnStop(0xc0001ea240)
        github.com/tendermint/tendermint/node/node.go:769 +0x132
github.com/tendermint/tendermint/libs/service.(*BaseService).Stop(0xc0001ea240, 0x0, 0x0)
        github.com/tendermint/tendermint/libs/service/service.go:171 +0x323
github.com/tendermint/tendermint/cmd/tendermint/commands.NewRunNodeCmd.func1.1()
        github.com/tendermint/tendermint/cmd/tendermint/commands/run_node.go:143 +0x62
github.com/tendermint/tendermint/libs/os.TrapSignal.func1(0xc000629500, 0x7fdb52f96358, 0xc0002b5030, 0xc00000daa0)
        github.com/tendermint/tendermint/libs/os/os.go:26 +0x102
created by github.com/tendermint/tendermint/libs/os.TrapSignal
        github.com/tendermint/tendermint/libs/os/os.go:22 +0xe6

goroutine 188 [semacquire]:
sync.runtime_SemacquireMutex(0xc00026b1cc, 0x0, 0x1)
        runtime/sema.go:71 +0x47
sync.(*Mutex).lockSlow(0xc00026b1c8)
        sync/mutex.go:138 +0x105
sync.(*Mutex).Lock(...)
        sync/mutex.go:81
sync.(*RWMutex).Lock(0xc00026b1c8)
        sync/rwmutex.go:111 +0x90
github.com/tendermint/tendermint/internal/statesync.(*Reactor).processPeerUpdate(0xc00026b080, 0xc000650008, 0x28, 0x124de90, 0x4)
        github.com/tendermint/tendermint/internal/statesync/reactor.go:849 +0x1a5
github.com/tendermint/tendermint/internal/statesync.(*Reactor).processPeerUpdates(0xc00026b080)
        github.com/tendermint/tendermint/internal/statesync/reactor.go:883 +0xab
created by github.com/tendermint/tendermint/internal/statesync.(*Reactor.OnStart
        github.com/tendermint/tendermint/internal/statesync/reactor.go:219 +0xcd)
```
---
 internal/statesync/reactor.go     | 10 +++++++---
 internal/statesync/syncer.go      | 13 ++++++++++++-
 internal/statesync/syncer_test.go |  6 ++++--
 3 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index a20c8ca41a..abfa973b5f 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -280,6 +280,7 @@ func (r *Reactor) Sync(ctx context.Context) (sm.State, error) {
 	}
 
 	if err := r.initStateProvider(ctx, r.chainID, r.initialHeight); err != nil {
+		r.mtx.Unlock()
 		return sm.State{}, err
 	}
 
@@ -889,17 +890,20 @@ func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
 	}
 
 	r.mtx.Lock()
+	defer r.mtx.Unlock()
 	if r.syncer == nil {
-		r.mtx.Unlock()
 		return
 	}
-	defer r.mtx.Unlock()
 
 	switch peerUpdate.Status {
 	case p2p.PeerStatusUp:
 		newProvider := NewBlockProvider(peerUpdate.NodeID, r.chainID, r.dispatcher)
 		r.providers[peerUpdate.NodeID] = newProvider
-		r.syncer.AddPeer(peerUpdate.NodeID)
+		err := r.syncer.AddPeer(peerUpdate.NodeID)
+		if err != nil {
+			r.Logger.Error("error adding peer to syncer", "error", err)
+			return
+		}
 		if sp, ok := r.stateProvider.(*stateProviderP2P); ok {
 			// we do this in a separate routine to not block whilst waiting for the light client to finish
 			// whatever call it's currently executing
diff --git a/internal/statesync/syncer.go b/internal/statesync/syncer.go
index 68bec68805..b4212961a3 100644
--- a/internal/statesync/syncer.go
+++ b/internal/statesync/syncer.go
@@ -141,7 +141,17 @@ func (s *syncer) AddSnapshot(peerID types.NodeID, snapshot *snapshot) (bool, err
 
 // AddPeer adds a peer to the pool. For now we just keep it simple and send a
 // single request to discover snapshots, later we may want to do retries and stuff.
-func (s *syncer) AddPeer(peerID types.NodeID) {
+func (s *syncer) AddPeer(peerID types.NodeID) (err error) {
+	defer func() {
+		// TODO: remove panic recover once AddPeer can no longer accientally send on
+		// closed channel.
+		// This recover was added to protect against the p2p message being sent
+		// to the snapshot channel after the snapshot channel was closed.
+		if r := recover(); r != nil {
+			err = fmt.Errorf("panic sending peer snapshot request: %v", r)
+		}
+	}()
+
 	s.logger.Debug("Requesting snapshots from peer", "peer", peerID)
 
 	msg := p2p.Envelope{
@@ -153,6 +163,7 @@ func (s *syncer) AddPeer(peerID types.NodeID) {
 	case <-s.closeCh:
 	case s.snapshotCh <- msg:
 	}
+	return err
 }
 
 // RemovePeer removes a peer from the pool.
diff --git a/internal/statesync/syncer_test.go b/internal/statesync/syncer_test.go
index 14297c0491..ad902a54c1 100644
--- a/internal/statesync/syncer_test.go
+++ b/internal/statesync/syncer_test.go
@@ -77,12 +77,14 @@ func TestSyncer_SyncAny(t *testing.T) {
 	require.Error(t, err)
 
 	// Adding a couple of peers should trigger snapshot discovery messages
-	rts.syncer.AddPeer(peerAID)
+	err = rts.syncer.AddPeer(peerAID)
+	require.NoError(t, err)
 	e := <-rts.snapshotOutCh
 	require.Equal(t, &ssproto.SnapshotsRequest{}, e.Message)
 	require.Equal(t, peerAID, e.To)
 
-	rts.syncer.AddPeer(peerBID)
+	err = rts.syncer.AddPeer(peerBID)
+	require.NoError(t, err)
 	e = <-rts.snapshotOutCh
 	require.Equal(t, &ssproto.SnapshotsRequest{}, e.Message)
 	require.Equal(t, peerBID, e.To)

From 243c62cc68a987095789cae34700235583f24f2d Mon Sep 17 00:00:00 2001
From: William Banfield <4561443+williambanfield@users.noreply.github.com>
Date: Fri, 1 Oct 2021 16:33:12 -0400
Subject: [PATCH 11/57] statesync: improve rare p2p race condition (#7042)

This is intended to fix a test failure that occurs in the p2p state provider. The issue presents as the state provider timing out waiting for the consensus params response.

The reason that this can occur is because the statesync reactor has the possibility of attempting to respond to the params request before the state provider is ready to read it. This results in the reactor hitting the `default` case seen here and then never sending on the channel. The stateprovider will then block waiting for a response and never receive one because the reactor opted not to send it.
---
 internal/statesync/reactor.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index abfa973b5f..70b12b7fa4 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -779,7 +779,8 @@ func (r *Reactor) handleParamsMessage(envelope p2p.Envelope) error {
 		if sp, ok := r.stateProvider.(*stateProviderP2P); ok {
 			select {
 			case sp.paramsRecvCh <- cp:
-			default:
+			case <-time.After(time.Second):
+				return errors.New("failed to send consensus params, stateprovider not ready for response")
 			}
 		} else {
 			r.Logger.Debug("received unexpected params response; using RPC state provider", "peer", envelope.From)

From f361ce09b31fb1f62c75ea952aaafbb597175344 Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Mon, 4 Oct 2021 08:40:50 -0700
Subject: [PATCH 12/57] Update Go toolchains to 1.17 in Actions workflows.
 (#7049)

---
 .github/workflows/coverage.yml           | 6 +++---
 .github/workflows/e2e-nightly-34x.yml    | 2 +-
 .github/workflows/e2e-nightly-master.yml | 2 +-
 .github/workflows/e2e.yml                | 2 +-
 .github/workflows/fuzz-nightly.yml       | 2 +-
 .github/workflows/release.yml            | 2 +-
 .github/workflows/tests.yml              | 6 +++---
 7 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 3553f63568..4a3b89074d 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -46,7 +46,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.16"
+          go-version: "1.17"
       - uses: actions/checkout@v2.3.4
       - uses: technote-space/get-diff-action@v5
         with:
@@ -69,7 +69,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.16"
+          go-version: "1.17"
       - uses: actions/checkout@v2.3.4
       - uses: technote-space/get-diff-action@v5
         with:
@@ -85,7 +85,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16
+          go-version: "1.17"
       - name: test & coverage report creation
         run: |
           cat pkgs.txt.part.${{ matrix.part }} | xargs go test -mod=readonly -timeout 8m -race -coverprofile=${{ matrix.part }}profile.out
diff --git a/.github/workflows/e2e-nightly-34x.yml b/.github/workflows/e2e-nightly-34x.yml
index 1b076d2ea4..d43bff12f2 100644
--- a/.github/workflows/e2e-nightly-34x.yml
+++ b/.github/workflows/e2e-nightly-34x.yml
@@ -23,7 +23,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.16'
+          go-version: '1.17'
 
       - uses: actions/checkout@v2.3.4
         with:
diff --git a/.github/workflows/e2e-nightly-master.yml b/.github/workflows/e2e-nightly-master.yml
index 5f5ed97065..95cb859e82 100644
--- a/.github/workflows/e2e-nightly-master.yml
+++ b/.github/workflows/e2e-nightly-master.yml
@@ -23,7 +23,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.16'
+          go-version: '1.17'
 
       - uses: actions/checkout@v2.3.4
 
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index 5cc605ead0..a0f18cd1b9 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -16,7 +16,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.16'
+          go-version: '1.17'
       - uses: actions/checkout@v2.3.4
       - uses: technote-space/get-diff-action@v5
         with:
diff --git a/.github/workflows/fuzz-nightly.yml b/.github/workflows/fuzz-nightly.yml
index c47dc44117..38ca6896d6 100644
--- a/.github/workflows/fuzz-nightly.yml
+++ b/.github/workflows/fuzz-nightly.yml
@@ -15,7 +15,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.16'
+          go-version: '1.17'
 
       - uses: actions/checkout@v2.3.4
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index dd18e750b1..567a607cab 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,7 +18,7 @@ jobs:
 
       - uses: actions/setup-go@v2
         with:
-          go-version: '1.16'
+          go-version: '1.17'
 
       - name: Build
         uses: goreleaser/goreleaser-action@v2
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 14d531812e..abb1e848eb 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -17,7 +17,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.16"
+          go-version: "1.17"
       - uses: actions/checkout@v2.3.4
       - uses: technote-space/get-diff-action@v5
         with:
@@ -49,7 +49,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.16"
+          go-version: "1.17"
       - uses: actions/checkout@v2.3.4
       - uses: technote-space/get-diff-action@v5
         with:
@@ -80,7 +80,7 @@ jobs:
     steps:
       - uses: actions/setup-go@v2
         with:
-          go-version: "1.16"
+          go-version: "1.17"
       - uses: actions/checkout@v2.3.4
       - uses: technote-space/get-diff-action@v5
         with:

From 6276fdcb5d23198a21dd8be9a067c931635c8b11 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Mon, 4 Oct 2021 13:04:15 -0400
Subject: [PATCH 13/57] ci: mergify support for 0.35 backports (#7050)

---
 .github/mergify.yml | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/.github/mergify.yml b/.github/mergify.yml
index 6b08c877fd..d492645973 100644
--- a/.github/mergify.yml
+++ b/.github/mergify.yml
@@ -16,3 +16,12 @@ pull_request_rules:
       backport:
         branches:
           - v0.34.x
+  - name: backport patches to v0.35.x branch
+    conditions:
+      - base=master
+      - label=S:backport-to-v0.35.x
+    actions:
+      backport:
+        branches:
+          - v0.35.x
+

From b30ec89ee98f72407d87062702ce137499633b08 Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Mon, 4 Oct 2021 10:35:16 -0700
Subject: [PATCH 14/57] Add an e2e workflow for the v0.35.x backport branch.
 (#7048)

---
 .github/workflows/e2e-nightly-35x.yml | 74 +++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 .github/workflows/e2e-nightly-35x.yml

diff --git a/.github/workflows/e2e-nightly-35x.yml b/.github/workflows/e2e-nightly-35x.yml
new file mode 100644
index 0000000000..b78812e925
--- /dev/null
+++ b/.github/workflows/e2e-nightly-35x.yml
@@ -0,0 +1,74 @@
+# Runs randomly generated E2E testnets nightly on v0.35.x.
+
+# !! If you change something in this file, you probably want
+# to update the e2e-nightly-master workflow as well!
+
+name: e2e-nightly-35x
+on:
+  workflow_dispatch: # allow running workflow manually
+  schedule:
+    - cron: '0 2 * * *'
+
+jobs:
+  e2e-nightly-test-2:
+    # Run parallel jobs for the listed testnet groups (must match the
+    # ./build/generator -g flag)
+    strategy:
+      fail-fast: false
+      matrix:
+        p2p: ['legacy', 'new', 'hybrid']
+        group: ['00', '01', '02', '03']
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/setup-go@v2
+        with:
+          go-version: '1.17'
+
+      - uses: actions/checkout@v2.3.4
+
+      - name: Build
+        working-directory: test/e2e
+        # Run make jobs in parallel, since we can't run steps in parallel.
+        run: make -j2 docker generator runner tests
+
+      - name: Generate testnets
+        working-directory: test/e2e
+        # When changing -g, also change the matrix groups above
+        run: ./build/generator -g 4 -d networks/nightly/${{ matrix.p2p }} -p ${{ matrix.p2p }}
+
+      - name: Run ${{ matrix.p2p }} p2p testnets in group ${{ matrix.group }}
+        working-directory: test/e2e
+        run: ./run-multiple.sh networks/nightly/${{ matrix.p2p }}/*-group${{ matrix.group }}-*.toml
+
+  e2e-nightly-fail-2:
+    needs: e2e-nightly-test-2
+    if: ${{ failure() }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Notify Slack on failure
+        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        env:
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
+          SLACK_CHANNEL: tendermint-internal
+          SLACK_USERNAME: Nightly E2E Tests
+          SLACK_ICON_EMOJI: ':skull:'
+          SLACK_COLOR: danger
+          SLACK_MESSAGE: Nightly E2E tests failed on v0.35.x
+          SLACK_FOOTER: ''
+
+  e2e-nightly-success: # may turn this off once they seem to pass consistently
+    needs: e2e-nightly-test-2
+    if: ${{ success() }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Notify Slack on success
+        uses: rtCamp/action-slack-notify@12e36fc18b0689399306c2e0b3e0f2978b7f1ee7
+        env:
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
+          SLACK_CHANNEL: tendermint-internal
+          SLACK_USERNAME: Nightly E2E Tests
+          SLACK_ICON_EMOJI: ':white_check_mark:'
+          SLACK_COLOR: good
+          SLACK_MESSAGE: Nightly E2E tests passed on v0.35.x
+          SLACK_FOOTER: ''

From c201e3b54d7db677febe759b4e4121135c087871 Mon Sep 17 00:00:00 2001
From: William Banfield <4561443+williambanfield@users.noreply.github.com>
Date: Mon, 4 Oct 2021 15:47:50 -0400
Subject: [PATCH 15/57] scripts: fix authors script to take a ref (#7051)

This script is referenced from the release documentation, we should make sure it's functional. This is helpful in generating the "Special Thanks" section of the changelog.
---
 scripts/authors.sh | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/scripts/authors.sh b/scripts/authors.sh
index 7aafb0127e..49251242ee 100755
--- a/scripts/authors.sh
+++ b/scripts/authors.sh
@@ -1,16 +1,16 @@
 #! /bin/bash
 
-# Usage:
-#   `./authors.sh`
-#		Print a list of all authors who have committed to develop since master.
-#
-#   `./authors.sh <email address>`
-#		Lookup the email address on Github and print the associated username
+set -euo pipefail
 
-author=$1
+ref=$1
 
-if [[ "$author" == "" ]]; then
-	git log master..develop | grep Author | sort | uniq
+if [[ ! -z "$ref" ]]; then
+	git log master..$ref | grep Author | sort | uniq
 else
-	curl -s "https://api.github.com/search/users?q=$author+in%3Aemail&type=Users&utf8=%E2%9C%93" | jq .items[0].login
+cat << EOF
+Usage:
+	./authors.sh <ref>
+		Print a list of all authors who have committed to the codebase since the supplied commit ref. 
+EOF
 fi
+

From cb69ed8135a04949475ac73976fcca994febbcbd Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Mon, 4 Oct 2021 17:12:51 -0400
Subject: [PATCH 16/57] blocksync/v2: remove unsupported reactor (#7046)

This commit should be one of the first to land as part of the v0.36
cycle *after* cutting the 0.35 branch.

The blocksync/v2 reactor was originally implemented as an experiement
to produce an implementation of the blockstack protocol that would be
easier to test and validate, but it was never appropriately
operationalized and this implementation was never fully debugged. When
the p2p layer was refactored as part of the 0.35 cycle, the v2
implementation was not refactored and it was left in the codebase but
not removed. This commit just removes all references to it.
---
 config/config.go                              |   18 +-
 config/config_test.go                         |    7 -
 config/toml.go                                |    5 -
 internal/blocksync/doc.go                     |   11 +-
 .../blocksync/v2/internal/behavior/doc.go     |   42 -
 .../v2/internal/behavior/peer_behaviour.go    |   47 -
 .../v2/internal/behavior/reporter.go          |   87 -
 .../v2/internal/behavior/reporter_test.go     |  205 --
 internal/blocksync/v2/io.go                   |  187 --
 internal/blocksync/v2/metrics.go              |  125 -
 internal/blocksync/v2/processor.go            |  193 --
 internal/blocksync/v2/processor_context.go    |  112 -
 internal/blocksync/v2/processor_test.go       |  305 ---
 internal/blocksync/v2/reactor.go              |  643 -----
 internal/blocksync/v2/reactor_test.go         |  533 ----
 internal/blocksync/v2/routine.go              |  166 --
 internal/blocksync/v2/routine_test.go         |  163 --
 internal/blocksync/v2/scheduler.go            |  711 ------
 internal/blocksync/v2/scheduler_test.go       | 2253 -----------------
 internal/blocksync/v2/types.go                |   65 -
 node/node.go                                  |    4 +-
 node/setup.go                                 |   65 +-
 test/e2e/networks/ci.toml                     |    1 +
 test/e2e/runner/setup.go                      |    3 +-
 24 files changed, 32 insertions(+), 5919 deletions(-)
 delete mode 100644 internal/blocksync/v2/internal/behavior/doc.go
 delete mode 100644 internal/blocksync/v2/internal/behavior/peer_behaviour.go
 delete mode 100644 internal/blocksync/v2/internal/behavior/reporter.go
 delete mode 100644 internal/blocksync/v2/internal/behavior/reporter_test.go
 delete mode 100644 internal/blocksync/v2/io.go
 delete mode 100644 internal/blocksync/v2/metrics.go
 delete mode 100644 internal/blocksync/v2/processor.go
 delete mode 100644 internal/blocksync/v2/processor_context.go
 delete mode 100644 internal/blocksync/v2/processor_test.go
 delete mode 100644 internal/blocksync/v2/reactor.go
 delete mode 100644 internal/blocksync/v2/reactor_test.go
 delete mode 100644 internal/blocksync/v2/routine.go
 delete mode 100644 internal/blocksync/v2/routine_test.go
 delete mode 100644 internal/blocksync/v2/scheduler.go
 delete mode 100644 internal/blocksync/v2/scheduler_test.go
 delete mode 100644 internal/blocksync/v2/types.go

diff --git a/config/config.go b/config/config.go
index dfc4836daf..79ce569351 100644
--- a/config/config.go
+++ b/config/config.go
@@ -30,7 +30,6 @@ const (
 	ModeSeed      = "seed"
 
 	BlockSyncV0 = "v0"
-	BlockSyncV2 = "v2"
 
 	MempoolV0 = "v0"
 	MempoolV1 = "v1"
@@ -1025,15 +1024,13 @@ func (cfg *StateSyncConfig) ValidateBasic() error {
 // allows them to catchup quickly by downloading blocks in parallel
 // and verifying their commits.
 type BlockSyncConfig struct {
-	Enable  bool   `mapstructure:"enable"`
-	Version string `mapstructure:"version"`
+	Enable bool `mapstructure:"enable"`
 }
 
 // DefaultBlockSyncConfig returns a default configuration for the block sync service
 func DefaultBlockSyncConfig() *BlockSyncConfig {
 	return &BlockSyncConfig{
-		Enable:  true,
-		Version: BlockSyncV0,
+		Enable: true,
 	}
 }
 
@@ -1043,16 +1040,7 @@ func TestBlockSyncConfig() *BlockSyncConfig {
 }
 
 // ValidateBasic performs basic validation.
-func (cfg *BlockSyncConfig) ValidateBasic() error {
-	switch cfg.Version {
-	case BlockSyncV0:
-		return nil
-	case BlockSyncV2:
-		return errors.New("blocksync version v2 is no longer supported. Please use v0")
-	default:
-		return fmt.Errorf("unknown blocksync version %s", cfg.Version)
-	}
-}
+func (cfg *BlockSyncConfig) ValidateBasic() error { return nil }
 
 //-----------------------------------------------------------------------------
 // ConsensusConfig
diff --git a/config/config_test.go b/config/config_test.go
index 075cedc6a3..79d6279102 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -128,13 +128,6 @@ func TestStateSyncConfigValidateBasic(t *testing.T) {
 func TestBlockSyncConfigValidateBasic(t *testing.T) {
 	cfg := TestBlockSyncConfig()
 	assert.NoError(t, cfg.ValidateBasic())
-
-	// tamper with version
-	cfg.Version = "v2"
-	assert.Error(t, cfg.ValidateBasic())
-
-	cfg.Version = "invalid"
-	assert.Error(t, cfg.ValidateBasic())
 }
 
 func TestConsensusConfig_ValidateBasic(t *testing.T) {
diff --git a/config/toml.go b/config/toml.go
index e4c86c9f46..6f07d6537b 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -477,11 +477,6 @@ fetchers = "{{ .StateSync.Fetchers }}"
 # and verifying their commits
 enable = {{ .BlockSync.Enable }}
 
-# Block Sync version to use:
-#   1) "v0" (default) - the standard Block Sync implementation
-#   2) "v2" - DEPRECATED, please use v0
-version = "{{ .BlockSync.Version }}"
-
 #######################################################
 ###         Consensus Configuration Options         ###
 #######################################################
diff --git a/internal/blocksync/doc.go b/internal/blocksync/doc.go
index 3111130e46..5f84b1261c 100644
--- a/internal/blocksync/doc.go
+++ b/internal/blocksync/doc.go
@@ -13,14 +13,9 @@ will no longer blocksync and thus no longer run the blocksync process.
 Note, the blocksync reactor Service gossips entire block and relevant data such
 that each receiving peer may construct the entire view of the blocksync state.
 
-There are currently two versions of the blocksync reactor Service:
-
-- v0: The initial implementation that is battle-tested, but whose test coverage
-	is lacking and is not formally verifiable.
-- v2: The latest implementation that has much higher test coverage and is formally
-	verified. However, the current implementation of v2 is not as battle-tested and
-	is known to have various bugs that could make it unreliable in production
-	environments.
+There is currently only one version of the blocksync reactor Service
+that is battle-tested, but whose test coverage is lacking and is not
+formally verified.
 
 The v0 blocksync reactor Service has one p2p channel, BlockchainChannel. This
 channel is responsible for handling messages that both request blocks and respond
diff --git a/internal/blocksync/v2/internal/behavior/doc.go b/internal/blocksync/v2/internal/behavior/doc.go
deleted file mode 100644
index c4bd06ccee..0000000000
--- a/internal/blocksync/v2/internal/behavior/doc.go
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
-Package Behavior provides a mechanism for reactors to report behavior of peers.
-
-Instead of a reactor calling the switch directly it will call the behavior module which will
-handle the stoping and marking peer as good on behalf of the reactor.
-
-There are four different behaviors a reactor can report.
-
-1. bad message
-
-type badMessage struct {
-	explanation string
-}
-
-This message will request the peer be stopped for an error
-
-2. message out of order
-
-type messageOutOfOrder struct {
-	explanation string
-}
-
-This message will request the peer be stopped for an error
-
-3. consesnsus Vote
-
-type consensusVote struct {
-	explanation string
-}
-
-This message will request the peer be marked as good
-
-4. block part
-
-type blockPart struct {
-	explanation string
-}
-
-This message will request the peer be marked as good
-
-*/
-package behavior
diff --git a/internal/blocksync/v2/internal/behavior/peer_behaviour.go b/internal/blocksync/v2/internal/behavior/peer_behaviour.go
deleted file mode 100644
index 90948d888c..0000000000
--- a/internal/blocksync/v2/internal/behavior/peer_behaviour.go
+++ /dev/null
@@ -1,47 +0,0 @@
-package behavior
-
-import "github.com/tendermint/tendermint/types"
-
-// PeerBehavior is a struct describing a behavior a peer performed.
-// `peerID` identifies the peer and reason characterizes the specific
-// behavior performed by the peer.
-type PeerBehavior struct {
-	peerID types.NodeID
-	reason interface{}
-}
-
-type badMessage struct {
-	explanation string
-}
-
-// BadMessage returns a badMessage PeerBehavior.
-func BadMessage(peerID types.NodeID, explanation string) PeerBehavior {
-	return PeerBehavior{peerID: peerID, reason: badMessage{explanation}}
-}
-
-type messageOutOfOrder struct {
-	explanation string
-}
-
-// MessageOutOfOrder returns a messagOutOfOrder PeerBehavior.
-func MessageOutOfOrder(peerID types.NodeID, explanation string) PeerBehavior {
-	return PeerBehavior{peerID: peerID, reason: messageOutOfOrder{explanation}}
-}
-
-type consensusVote struct {
-	explanation string
-}
-
-// ConsensusVote returns a consensusVote PeerBehavior.
-func ConsensusVote(peerID types.NodeID, explanation string) PeerBehavior {
-	return PeerBehavior{peerID: peerID, reason: consensusVote{explanation}}
-}
-
-type blockPart struct {
-	explanation string
-}
-
-// BlockPart returns blockPart PeerBehavior.
-func BlockPart(peerID types.NodeID, explanation string) PeerBehavior {
-	return PeerBehavior{peerID: peerID, reason: blockPart{explanation}}
-}
diff --git a/internal/blocksync/v2/internal/behavior/reporter.go b/internal/blocksync/v2/internal/behavior/reporter.go
deleted file mode 100644
index c150a98d53..0000000000
--- a/internal/blocksync/v2/internal/behavior/reporter.go
+++ /dev/null
@@ -1,87 +0,0 @@
-package behavior
-
-import (
-	"errors"
-
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/types"
-)
-
-// Reporter provides an interface for reactors to report the behavior
-// of peers synchronously to other components.
-type Reporter interface {
-	Report(behavior PeerBehavior) error
-}
-
-// SwitchReporter reports peer behavior to an internal Switch.
-type SwitchReporter struct {
-	sw *p2p.Switch
-}
-
-// NewSwitchReporter return a new SwitchReporter instance which wraps the Switch.
-func NewSwitchReporter(sw *p2p.Switch) *SwitchReporter {
-	return &SwitchReporter{
-		sw: sw,
-	}
-}
-
-// Report reports the behavior of a peer to the Switch.
-func (spbr *SwitchReporter) Report(behavior PeerBehavior) error {
-	peer := spbr.sw.Peers().Get(behavior.peerID)
-	if peer == nil {
-		return errors.New("peer not found")
-	}
-
-	switch reason := behavior.reason.(type) {
-	case consensusVote, blockPart:
-		spbr.sw.MarkPeerAsGood(peer)
-	case badMessage:
-		spbr.sw.StopPeerForError(peer, reason.explanation)
-	case messageOutOfOrder:
-		spbr.sw.StopPeerForError(peer, reason.explanation)
-	default:
-		return errors.New("unknown reason reported")
-	}
-
-	return nil
-}
-
-// MockReporter is a concrete implementation of the Reporter
-// interface used in reactor tests to ensure reactors report the correct
-// behavior in manufactured scenarios.
-type MockReporter struct {
-	mtx tmsync.RWMutex
-	pb  map[types.NodeID][]PeerBehavior
-}
-
-// NewMockReporter returns a Reporter which records all reported
-// behaviors in memory.
-func NewMockReporter() *MockReporter {
-	return &MockReporter{
-		pb: map[types.NodeID][]PeerBehavior{},
-	}
-}
-
-// Report stores the PeerBehavior produced by the peer identified by peerID.
-func (mpbr *MockReporter) Report(behavior PeerBehavior) error {
-	mpbr.mtx.Lock()
-	defer mpbr.mtx.Unlock()
-	mpbr.pb[behavior.peerID] = append(mpbr.pb[behavior.peerID], behavior)
-
-	return nil
-}
-
-// GetBehaviors returns all behaviors reported on the peer identified by peerID.
-func (mpbr *MockReporter) GetBehaviors(peerID types.NodeID) []PeerBehavior {
-	mpbr.mtx.RLock()
-	defer mpbr.mtx.RUnlock()
-	if items, ok := mpbr.pb[peerID]; ok {
-		result := make([]PeerBehavior, len(items))
-		copy(result, items)
-
-		return result
-	}
-
-	return []PeerBehavior{}
-}
diff --git a/internal/blocksync/v2/internal/behavior/reporter_test.go b/internal/blocksync/v2/internal/behavior/reporter_test.go
deleted file mode 100644
index 861a63df0c..0000000000
--- a/internal/blocksync/v2/internal/behavior/reporter_test.go
+++ /dev/null
@@ -1,205 +0,0 @@
-package behavior_test
-
-import (
-	"sync"
-	"testing"
-
-	bh "github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior"
-	"github.com/tendermint/tendermint/types"
-)
-
-// TestMockReporter tests the MockReporter's ability to store reported
-// peer behavior in memory indexed by the peerID.
-func TestMockReporter(t *testing.T) {
-	var peerID types.NodeID = "MockPeer"
-	pr := bh.NewMockReporter()
-
-	behaviors := pr.GetBehaviors(peerID)
-	if len(behaviors) != 0 {
-		t.Error("Expected to have no behaviors reported")
-	}
-
-	badMessage := bh.BadMessage(peerID, "bad message")
-	if err := pr.Report(badMessage); err != nil {
-		t.Error(err)
-	}
-	behaviors = pr.GetBehaviors(peerID)
-	if len(behaviors) != 1 {
-		t.Error("Expected the peer have one reported behavior")
-	}
-
-	if behaviors[0] != badMessage {
-		t.Error("Expected Bad Message to have been reported")
-	}
-}
-
-type scriptItem struct {
-	peerID   types.NodeID
-	behavior bh.PeerBehavior
-}
-
-// equalBehaviors returns true if a and b contain the same PeerBehaviors with
-// the same freequencies and otherwise false.
-func equalBehaviors(a []bh.PeerBehavior, b []bh.PeerBehavior) bool {
-	aHistogram := map[bh.PeerBehavior]int{}
-	bHistogram := map[bh.PeerBehavior]int{}
-
-	for _, behavior := range a {
-		aHistogram[behavior]++
-	}
-
-	for _, behavior := range b {
-		bHistogram[behavior]++
-	}
-
-	if len(aHistogram) != len(bHistogram) {
-		return false
-	}
-
-	for _, behavior := range a {
-		if aHistogram[behavior] != bHistogram[behavior] {
-			return false
-		}
-	}
-
-	for _, behavior := range b {
-		if bHistogram[behavior] != aHistogram[behavior] {
-			return false
-		}
-	}
-
-	return true
-}
-
-// TestEqualPeerBehaviors tests that equalBehaviors can tell that two slices
-// of peer behaviors can be compared for the behaviors they contain and the
-// freequencies that those behaviors occur.
-func TestEqualPeerBehaviors(t *testing.T) {
-	var (
-		peerID        types.NodeID = "MockPeer"
-		consensusVote              = bh.ConsensusVote(peerID, "voted")
-		blockPart                  = bh.BlockPart(peerID, "blocked")
-		equals                     = []struct {
-			left  []bh.PeerBehavior
-			right []bh.PeerBehavior
-		}{
-			// Empty sets
-			{[]bh.PeerBehavior{}, []bh.PeerBehavior{}},
-			// Single behaviors
-			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{consensusVote}},
-			// Equal Frequencies
-			{[]bh.PeerBehavior{consensusVote, consensusVote},
-				[]bh.PeerBehavior{consensusVote, consensusVote}},
-			// Equal frequencies different orders
-			{[]bh.PeerBehavior{consensusVote, blockPart},
-				[]bh.PeerBehavior{blockPart, consensusVote}},
-		}
-		unequals = []struct {
-			left  []bh.PeerBehavior
-			right []bh.PeerBehavior
-		}{
-			// Comparing empty sets to non empty sets
-			{[]bh.PeerBehavior{}, []bh.PeerBehavior{consensusVote}},
-			// Different behaviors
-			{[]bh.PeerBehavior{consensusVote}, []bh.PeerBehavior{blockPart}},
-			// Same behavior with different frequencies
-			{[]bh.PeerBehavior{consensusVote},
-				[]bh.PeerBehavior{consensusVote, consensusVote}},
-		}
-	)
-
-	for _, test := range equals {
-		if !equalBehaviors(test.left, test.right) {
-			t.Errorf("expected %#v and %#v to be equal", test.left, test.right)
-		}
-	}
-
-	for _, test := range unequals {
-		if equalBehaviors(test.left, test.right) {
-			t.Errorf("expected %#v and %#v to be unequal", test.left, test.right)
-		}
-	}
-}
-
-// TestPeerBehaviorConcurrency constructs a scenario in which
-// multiple goroutines are using the same MockReporter instance.
-// This test reproduces the conditions in which MockReporter will
-// be used within a Reactor `Receive` method tests to ensure thread safety.
-func TestMockPeerBehaviorReporterConcurrency(t *testing.T) {
-	var (
-		behaviorScript = []struct {
-			peerID    types.NodeID
-			behaviors []bh.PeerBehavior
-		}{
-			{"1", []bh.PeerBehavior{bh.ConsensusVote("1", "")}},
-			{"2", []bh.PeerBehavior{bh.ConsensusVote("2", ""), bh.ConsensusVote("2", ""), bh.ConsensusVote("2", "")}},
-			{
-				"3",
-				[]bh.PeerBehavior{bh.BlockPart("3", ""),
-					bh.ConsensusVote("3", ""),
-					bh.BlockPart("3", ""),
-					bh.ConsensusVote("3", "")}},
-			{
-				"4",
-				[]bh.PeerBehavior{bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", ""),
-					bh.ConsensusVote("4", "")}},
-			{
-				"5",
-				[]bh.PeerBehavior{bh.BlockPart("5", ""),
-					bh.ConsensusVote("5", ""),
-					bh.BlockPart("5", ""),
-					bh.ConsensusVote("5", "")}},
-		}
-	)
-
-	var receiveWg sync.WaitGroup
-	pr := bh.NewMockReporter()
-	scriptItems := make(chan scriptItem)
-	done := make(chan int)
-	numConsumers := 3
-	for i := 0; i < numConsumers; i++ {
-		receiveWg.Add(1)
-		go func() {
-			defer receiveWg.Done()
-			for {
-				select {
-				case pb := <-scriptItems:
-					if err := pr.Report(pb.behavior); err != nil {
-						t.Error(err)
-					}
-				case <-done:
-					return
-				}
-			}
-		}()
-	}
-
-	var sendingWg sync.WaitGroup
-	sendingWg.Add(1)
-	go func() {
-		defer sendingWg.Done()
-		for _, item := range behaviorScript {
-			for _, reason := range item.behaviors {
-				scriptItems <- scriptItem{item.peerID, reason}
-			}
-		}
-	}()
-
-	sendingWg.Wait()
-
-	for i := 0; i < numConsumers; i++ {
-		done <- 1
-	}
-
-	receiveWg.Wait()
-
-	for _, items := range behaviorScript {
-		reported := pr.GetBehaviors(items.peerID)
-		if !equalBehaviors(reported, items.behaviors) {
-			t.Errorf("expected peer %s to have behaved \nExpected: %#v \nGot %#v \n",
-				items.peerID, items.behaviors, reported)
-		}
-	}
-}
diff --git a/internal/blocksync/v2/io.go b/internal/blocksync/v2/io.go
deleted file mode 100644
index b272db3ae5..0000000000
--- a/internal/blocksync/v2/io.go
+++ /dev/null
@@ -1,187 +0,0 @@
-package v2
-
-import (
-	"errors"
-
-	"github.com/gogo/protobuf/proto"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/state"
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
-	"github.com/tendermint/tendermint/types"
-)
-
-var (
-	errPeerQueueFull = errors.New("peer queue full")
-)
-
-type iIO interface {
-	sendBlockRequest(peer p2p.Peer, height int64) error
-	sendBlockToPeer(block *types.Block, peer p2p.Peer) error
-	sendBlockNotFound(height int64, peer p2p.Peer) error
-	sendStatusResponse(base, height int64, peer p2p.Peer) error
-
-	sendStatusRequest(peer p2p.Peer) error
-	broadcastStatusRequest() error
-
-	trySwitchToConsensus(state state.State, skipWAL bool) bool
-}
-
-type switchIO struct {
-	sw *p2p.Switch
-}
-
-func newSwitchIo(sw *p2p.Switch) *switchIO {
-	return &switchIO{
-		sw: sw,
-	}
-}
-
-const (
-	// BlockchainChannel is a channel for blocks and status updates (`BlockStore` height)
-	BlockchainChannel = byte(0x40)
-)
-
-type consensusReactor interface {
-	// for when we switch from blockchain reactor and block sync to
-	// the consensus machine
-	SwitchToConsensus(state state.State, skipWAL bool)
-}
-
-func (sio *switchIO) sendBlockRequest(peer p2p.Peer, height int64) error {
-	msgProto := &bcproto.Message{
-		Sum: &bcproto.Message_BlockRequest{
-			BlockRequest: &bcproto.BlockRequest{
-				Height: height,
-			},
-		},
-	}
-
-	msgBytes, err := proto.Marshal(msgProto)
-	if err != nil {
-		return err
-	}
-
-	queued := peer.TrySend(BlockchainChannel, msgBytes)
-	if !queued {
-		return errPeerQueueFull
-	}
-	return nil
-}
-
-func (sio *switchIO) sendStatusResponse(base int64, height int64, peer p2p.Peer) error {
-	msgProto := &bcproto.Message{
-		Sum: &bcproto.Message_StatusResponse{
-			StatusResponse: &bcproto.StatusResponse{
-				Height: height,
-				Base:   base,
-			},
-		},
-	}
-
-	msgBytes, err := proto.Marshal(msgProto)
-	if err != nil {
-		return err
-	}
-
-	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
-		return errPeerQueueFull
-	}
-
-	return nil
-}
-
-func (sio *switchIO) sendBlockToPeer(block *types.Block, peer p2p.Peer) error {
-	if block == nil {
-		panic("trying to send nil block")
-	}
-
-	bpb, err := block.ToProto()
-	if err != nil {
-		return err
-	}
-
-	msgProto := &bcproto.Message{
-		Sum: &bcproto.Message_BlockResponse{
-			BlockResponse: &bcproto.BlockResponse{
-				Block: bpb,
-			},
-		},
-	}
-
-	msgBytes, err := proto.Marshal(msgProto)
-	if err != nil {
-		return err
-	}
-
-	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
-		return errPeerQueueFull
-	}
-
-	return nil
-}
-
-func (sio *switchIO) sendBlockNotFound(height int64, peer p2p.Peer) error {
-	msgProto := &bcproto.Message{
-		Sum: &bcproto.Message_NoBlockResponse{
-			NoBlockResponse: &bcproto.NoBlockResponse{
-				Height: height,
-			},
-		},
-	}
-
-	msgBytes, err := proto.Marshal(msgProto)
-	if err != nil {
-		return err
-	}
-
-	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
-		return errPeerQueueFull
-	}
-
-	return nil
-}
-
-func (sio *switchIO) trySwitchToConsensus(state state.State, skipWAL bool) bool {
-	conR, ok := sio.sw.Reactor("CONSENSUS").(consensusReactor)
-	if ok {
-		conR.SwitchToConsensus(state, skipWAL)
-	}
-	return ok
-}
-
-func (sio *switchIO) sendStatusRequest(peer p2p.Peer) error {
-	msgProto := &bcproto.Message{
-		Sum: &bcproto.Message_StatusRequest{
-			StatusRequest: &bcproto.StatusRequest{},
-		},
-	}
-
-	msgBytes, err := proto.Marshal(msgProto)
-	if err != nil {
-		return err
-	}
-
-	if queued := peer.TrySend(BlockchainChannel, msgBytes); !queued {
-		return errPeerQueueFull
-	}
-
-	return nil
-}
-
-func (sio *switchIO) broadcastStatusRequest() error {
-	msgProto := &bcproto.Message{
-		Sum: &bcproto.Message_StatusRequest{
-			StatusRequest: &bcproto.StatusRequest{},
-		},
-	}
-
-	msgBytes, err := proto.Marshal(msgProto)
-	if err != nil {
-		return err
-	}
-
-	// XXX: maybe we should use an io specific peer list here
-	sio.sw.Broadcast(BlockchainChannel, msgBytes)
-
-	return nil
-}
diff --git a/internal/blocksync/v2/metrics.go b/internal/blocksync/v2/metrics.go
deleted file mode 100644
index c68ec64476..0000000000
--- a/internal/blocksync/v2/metrics.go
+++ /dev/null
@@ -1,125 +0,0 @@
-package v2
-
-import (
-	"github.com/go-kit/kit/metrics"
-	"github.com/go-kit/kit/metrics/discard"
-	"github.com/go-kit/kit/metrics/prometheus"
-	stdprometheus "github.com/prometheus/client_golang/prometheus"
-)
-
-const (
-	// MetricsSubsystem is a subsystem shared by all metrics exposed by this
-	// package.
-	MetricsSubsystem = "blockchain"
-)
-
-// Metrics contains metrics exposed by this package.
-type Metrics struct {
-	// events_in
-	EventsIn metrics.Counter
-	// events_in
-	EventsHandled metrics.Counter
-	// events_out
-	EventsOut metrics.Counter
-	// errors_in
-	ErrorsIn metrics.Counter
-	// errors_handled
-	ErrorsHandled metrics.Counter
-	// errors_out
-	ErrorsOut metrics.Counter
-	// events_shed
-	EventsShed metrics.Counter
-	// events_sent
-	EventsSent metrics.Counter
-	// errors_sent
-	ErrorsSent metrics.Counter
-	// errors_shed
-	ErrorsShed metrics.Counter
-}
-
-// PrometheusMetrics returns metrics for in and out events, errors, etc. handled by routines.
-// Can we burn in the routine name here?
-func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics {
-	labels := []string{}
-	for i := 0; i < len(labelsAndValues); i += 2 {
-		labels = append(labels, labelsAndValues[i])
-	}
-	return &Metrics{
-		EventsIn: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "events_in",
-			Help:      "Events read from the channel.",
-		}, labels).With(labelsAndValues...),
-		EventsHandled: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "events_handled",
-			Help:      "Events handled",
-		}, labels).With(labelsAndValues...),
-		EventsOut: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "events_out",
-			Help:      "Events output from routine.",
-		}, labels).With(labelsAndValues...),
-		ErrorsIn: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "errors_in",
-			Help:      "Errors read from the channel.",
-		}, labels).With(labelsAndValues...),
-		ErrorsHandled: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "errors_handled",
-			Help:      "Errors handled.",
-		}, labels).With(labelsAndValues...),
-		ErrorsOut: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "errors_out",
-			Help:      "Errors output from routine.",
-		}, labels).With(labelsAndValues...),
-		ErrorsSent: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "errors_sent",
-			Help:      "Errors sent to routine.",
-		}, labels).With(labelsAndValues...),
-		ErrorsShed: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "errors_shed",
-			Help:      "Errors dropped from sending.",
-		}, labels).With(labelsAndValues...),
-		EventsSent: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "events_sent",
-			Help:      "Events sent to routine.",
-		}, labels).With(labelsAndValues...),
-		EventsShed: prometheus.NewCounterFrom(stdprometheus.CounterOpts{
-			Namespace: namespace,
-			Subsystem: MetricsSubsystem,
-			Name:      "events_shed",
-			Help:      "Events dropped from sending.",
-		}, labels).With(labelsAndValues...),
-	}
-}
-
-// NopMetrics returns no-op Metrics.
-func NopMetrics() *Metrics {
-	return &Metrics{
-		EventsIn:      discard.NewCounter(),
-		EventsHandled: discard.NewCounter(),
-		EventsOut:     discard.NewCounter(),
-		ErrorsIn:      discard.NewCounter(),
-		ErrorsHandled: discard.NewCounter(),
-		ErrorsOut:     discard.NewCounter(),
-		EventsShed:    discard.NewCounter(),
-		EventsSent:    discard.NewCounter(),
-		ErrorsSent:    discard.NewCounter(),
-		ErrorsShed:    discard.NewCounter(),
-	}
-}
diff --git a/internal/blocksync/v2/processor.go b/internal/blocksync/v2/processor.go
deleted file mode 100644
index d1850eb1ce..0000000000
--- a/internal/blocksync/v2/processor.go
+++ /dev/null
@@ -1,193 +0,0 @@
-package v2
-
-import (
-	"fmt"
-
-	tmstate "github.com/tendermint/tendermint/internal/state"
-	"github.com/tendermint/tendermint/types"
-)
-
-// Events generated by the processor:
-// block execution failure, event will indicate the peer(s) that caused the error
-type pcBlockVerificationFailure struct {
-	priorityNormal
-	height       int64
-	firstPeerID  types.NodeID
-	secondPeerID types.NodeID
-}
-
-func (e pcBlockVerificationFailure) String() string {
-	return fmt.Sprintf("pcBlockVerificationFailure{%d 1st peer: %v, 2nd peer: %v}",
-		e.height, e.firstPeerID, e.secondPeerID)
-}
-
-// successful block execution
-type pcBlockProcessed struct {
-	priorityNormal
-	height int64
-	peerID types.NodeID
-}
-
-func (e pcBlockProcessed) String() string {
-	return fmt.Sprintf("pcBlockProcessed{%d peer: %v}", e.height, e.peerID)
-}
-
-// processor has finished
-type pcFinished struct {
-	priorityNormal
-	blocksSynced int
-	tmState      tmstate.State
-}
-
-func (p pcFinished) Error() string {
-	return "finished"
-}
-
-type queueItem struct {
-	block  *types.Block
-	peerID types.NodeID
-}
-
-type blockQueue map[int64]queueItem
-
-type pcState struct {
-	// blocks waiting to be processed
-	queue blockQueue
-
-	// draining indicates that the next rProcessBlock event with a queue miss constitutes completion
-	draining bool
-
-	// the number of blocks successfully synced by the processor
-	blocksSynced int
-
-	// the processorContext which contains the processor dependencies
-	context processorContext
-}
-
-func (state *pcState) String() string {
-	return fmt.Sprintf("height: %d queue length: %d draining: %v blocks synced: %d",
-		state.height(), len(state.queue), state.draining, state.blocksSynced)
-}
-
-// newPcState returns a pcState initialized with the last verified block enqueued
-func newPcState(context processorContext) *pcState {
-	return &pcState{
-		queue:        blockQueue{},
-		draining:     false,
-		blocksSynced: 0,
-		context:      context,
-	}
-}
-
-// nextTwo returns the next two unverified blocks
-func (state *pcState) nextTwo() (queueItem, queueItem, error) {
-	if first, ok := state.queue[state.height()+1]; ok {
-		if second, ok := state.queue[state.height()+2]; ok {
-			return first, second, nil
-		}
-	}
-	return queueItem{}, queueItem{}, fmt.Errorf("not found")
-}
-
-// synced returns true when at most the last verified block remains in the queue
-func (state *pcState) synced() bool {
-	return len(state.queue) <= 1
-}
-
-func (state *pcState) enqueue(peerID types.NodeID, block *types.Block, height int64) {
-	if item, ok := state.queue[height]; ok {
-		panic(fmt.Sprintf(
-			"duplicate block %d (%X) enqueued by processor (sent by %v; existing block %X from %v)",
-			height, block.Hash(), peerID, item.block.Hash(), item.peerID))
-	}
-
-	state.queue[height] = queueItem{block: block, peerID: peerID}
-}
-
-func (state *pcState) height() int64 {
-	return state.context.tmState().LastBlockHeight
-}
-
-// purgePeer moves all unprocessed blocks from the queue
-func (state *pcState) purgePeer(peerID types.NodeID) {
-	// what if height is less than state.height?
-	for height, item := range state.queue {
-		if item.peerID == peerID {
-			delete(state.queue, height)
-		}
-	}
-}
-
-// handle processes FSM events
-func (state *pcState) handle(event Event) (Event, error) {
-	switch event := event.(type) {
-	case bcResetState:
-		state.context.setState(event.state)
-		return noOp, nil
-
-	case scFinishedEv:
-		if state.synced() {
-			return pcFinished{tmState: state.context.tmState(), blocksSynced: state.blocksSynced}, nil
-		}
-		state.draining = true
-		return noOp, nil
-
-	case scPeerError:
-		state.purgePeer(event.peerID)
-		return noOp, nil
-
-	case scBlockReceived:
-		if event.block == nil {
-			return noOp, nil
-		}
-
-		// enqueue block if height is higher than state height, else ignore it
-		if event.block.Height > state.height() {
-			state.enqueue(event.peerID, event.block, event.block.Height)
-		}
-		return noOp, nil
-
-	case rProcessBlock:
-		tmstate := state.context.tmState()
-		firstItem, secondItem, err := state.nextTwo()
-		if err != nil {
-			if state.draining {
-				return pcFinished{tmState: tmstate, blocksSynced: state.blocksSynced}, nil
-			}
-			return noOp, nil
-		}
-
-		var (
-			first, second = firstItem.block, secondItem.block
-			firstParts    = first.MakePartSet(types.BlockPartSizeBytes)
-			firstID       = types.BlockID{Hash: first.Hash(), PartSetHeader: firstParts.Header()}
-		)
-
-		// verify if +second+ last commit "confirms" +first+ block
-		err = state.context.verifyCommit(tmstate.ChainID, firstID, first.Height, second.LastCommit)
-		if err != nil {
-			state.purgePeer(firstItem.peerID)
-			if firstItem.peerID != secondItem.peerID {
-				state.purgePeer(secondItem.peerID)
-			}
-			return pcBlockVerificationFailure{
-					height: first.Height, firstPeerID: firstItem.peerID, secondPeerID: secondItem.peerID},
-				nil
-		}
-
-		state.context.saveBlock(first, firstParts, second.LastCommit)
-
-		if err := state.context.applyBlock(firstID, first); err != nil {
-			panic(fmt.Sprintf("failed to process committed block (%d:%X): %v", first.Height, first.Hash(), err))
-		}
-
-		state.context.recordConsMetrics(first)
-
-		delete(state.queue, first.Height)
-		state.blocksSynced++
-
-		return pcBlockProcessed{height: first.Height, peerID: firstItem.peerID}, nil
-	}
-
-	return noOp, nil
-}
diff --git a/internal/blocksync/v2/processor_context.go b/internal/blocksync/v2/processor_context.go
deleted file mode 100644
index 86b380f98a..0000000000
--- a/internal/blocksync/v2/processor_context.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package v2
-
-import (
-	"fmt"
-
-	"github.com/tendermint/tendermint/internal/consensus"
-	"github.com/tendermint/tendermint/internal/state"
-	"github.com/tendermint/tendermint/types"
-)
-
-type processorContext interface {
-	applyBlock(blockID types.BlockID, block *types.Block) error
-	verifyCommit(chainID string, blockID types.BlockID, height int64, commit *types.Commit) error
-	saveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit)
-	tmState() state.State
-	setState(state.State)
-	recordConsMetrics(block *types.Block)
-}
-
-type pContext struct {
-	store   blockStore
-	applier blockApplier
-	state   state.State
-	metrics *consensus.Metrics
-}
-
-func newProcessorContext(st blockStore, ex blockApplier, s state.State, m *consensus.Metrics) *pContext {
-	return &pContext{
-		store:   st,
-		applier: ex,
-		state:   s,
-		metrics: m,
-	}
-}
-
-func (pc *pContext) applyBlock(blockID types.BlockID, block *types.Block) error {
-	newState, err := pc.applier.ApplyBlock(pc.state, blockID, block)
-	pc.state = newState
-	return err
-}
-
-func (pc pContext) tmState() state.State {
-	return pc.state
-}
-
-func (pc *pContext) setState(state state.State) {
-	pc.state = state
-}
-
-func (pc pContext) verifyCommit(chainID string, blockID types.BlockID, height int64, commit *types.Commit) error {
-	return pc.state.Validators.VerifyCommitLight(chainID, blockID, height, commit)
-}
-
-func (pc *pContext) saveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
-	pc.store.SaveBlock(block, blockParts, seenCommit)
-}
-
-func (pc *pContext) recordConsMetrics(block *types.Block) {
-	pc.metrics.RecordConsMetrics(block)
-}
-
-type mockPContext struct {
-	applicationBL  []int64
-	verificationBL []int64
-	state          state.State
-}
-
-func newMockProcessorContext(
-	state state.State,
-	verificationBlackList []int64,
-	applicationBlackList []int64) *mockPContext {
-	return &mockPContext{
-		applicationBL:  applicationBlackList,
-		verificationBL: verificationBlackList,
-		state:          state,
-	}
-}
-
-func (mpc *mockPContext) applyBlock(blockID types.BlockID, block *types.Block) error {
-	for _, h := range mpc.applicationBL {
-		if h == block.Height {
-			return fmt.Errorf("generic application error")
-		}
-	}
-	mpc.state.LastBlockHeight = block.Height
-	return nil
-}
-
-func (mpc *mockPContext) verifyCommit(chainID string, blockID types.BlockID, height int64, commit *types.Commit) error {
-	for _, h := range mpc.verificationBL {
-		if h == height {
-			return fmt.Errorf("generic verification error")
-		}
-	}
-	return nil
-}
-
-func (mpc *mockPContext) saveBlock(block *types.Block, blockParts *types.PartSet, seenCommit *types.Commit) {
-
-}
-
-func (mpc *mockPContext) setState(state state.State) {
-	mpc.state = state
-}
-
-func (mpc *mockPContext) tmState() state.State {
-	return mpc.state
-}
-
-func (mpc *mockPContext) recordConsMetrics(block *types.Block) {
-
-}
diff --git a/internal/blocksync/v2/processor_test.go b/internal/blocksync/v2/processor_test.go
deleted file mode 100644
index 7c12b36108..0000000000
--- a/internal/blocksync/v2/processor_test.go
+++ /dev/null
@@ -1,305 +0,0 @@
-package v2
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	tmstate "github.com/tendermint/tendermint/internal/state"
-	"github.com/tendermint/tendermint/types"
-)
-
-// pcBlock is a test helper structure with simple types. Its purpose is to help with test readability.
-type pcBlock struct {
-	pid    string
-	height int64
-}
-
-// params is a test structure used to create processor state.
-type params struct {
-	height       int64
-	items        []pcBlock
-	blocksSynced int
-	verBL        []int64
-	appBL        []int64
-	draining     bool
-}
-
-// makePcBlock makes an empty block.
-func makePcBlock(height int64) *types.Block {
-	return &types.Block{Header: types.Header{Height: height}}
-}
-
-// makeState takes test parameters and creates a specific processor state.
-func makeState(p *params) *pcState {
-	var (
-		tmState = tmstate.State{LastBlockHeight: p.height}
-		context = newMockProcessorContext(tmState, p.verBL, p.appBL)
-	)
-	state := newPcState(context)
-
-	for _, item := range p.items {
-		state.enqueue(types.NodeID(item.pid), makePcBlock(item.height), item.height)
-	}
-
-	state.blocksSynced = p.blocksSynced
-	state.draining = p.draining
-	return state
-}
-
-func mBlockResponse(peerID types.NodeID, height int64) scBlockReceived {
-	return scBlockReceived{
-		peerID: peerID,
-		block:  makePcBlock(height),
-	}
-}
-
-type pcFsmMakeStateValues struct {
-	currentState  *params
-	event         Event
-	wantState     *params
-	wantNextEvent Event
-	wantErr       error
-	wantPanic     bool
-}
-
-type testFields struct {
-	name  string
-	steps []pcFsmMakeStateValues
-}
-
-func executeProcessorTests(t *testing.T, tests []testFields) {
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			var state *pcState
-			for _, step := range tt.steps {
-				defer func() {
-					r := recover()
-					if (r != nil) != step.wantPanic {
-						t.Errorf("recover = %v, wantPanic = %v", r, step.wantPanic)
-					}
-				}()
-
-				// First step must always initialize the currentState as state.
-				if step.currentState != nil {
-					state = makeState(step.currentState)
-				}
-				if state == nil {
-					panic("Bad (initial?) step")
-				}
-
-				nextEvent, err := state.handle(step.event)
-				t.Log(state)
-				assert.Equal(t, step.wantErr, err)
-				assert.Equal(t, makeState(step.wantState), state)
-				assert.Equal(t, step.wantNextEvent, nextEvent)
-				// Next step may use the wantedState as their currentState.
-				state = makeState(step.wantState)
-			}
-		})
-	}
-}
-
-func TestRProcessPeerError(t *testing.T) {
-	tests := []testFields{
-		{
-			name: "error for existing peer",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState:  &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}},
-					event:         scPeerError{peerID: "P2"},
-					wantState:     &params{items: []pcBlock{{"P1", 1}}},
-					wantNextEvent: noOp,
-				},
-			},
-		},
-		{
-			name: "error for unknown peer",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState:  &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}},
-					event:         scPeerError{peerID: "P3"},
-					wantState:     &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}},
-					wantNextEvent: noOp,
-				},
-			},
-		},
-	}
-
-	executeProcessorTests(t, tests)
-}
-
-func TestPcBlockResponse(t *testing.T) {
-	tests := []testFields{
-		{
-			name: "add one block",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{}, event: mBlockResponse("P1", 1),
-					wantState: &params{items: []pcBlock{{"P1", 1}}}, wantNextEvent: noOp,
-				},
-			},
-		},
-
-		{
-			name: "add two blocks",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{}, event: mBlockResponse("P1", 3),
-					wantState: &params{items: []pcBlock{{"P1", 3}}}, wantNextEvent: noOp,
-				},
-				{ // use previous wantState as currentState,
-					event:     mBlockResponse("P1", 4),
-					wantState: &params{items: []pcBlock{{"P1", 3}, {"P1", 4}}}, wantNextEvent: noOp,
-				},
-			},
-		},
-	}
-
-	executeProcessorTests(t, tests)
-}
-
-func TestRProcessBlockSuccess(t *testing.T) {
-	tests := []testFields{
-		{
-			name: "noop - no blocks over current height",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{}, event: rProcessBlock{},
-					wantState: &params{}, wantNextEvent: noOp,
-				},
-			},
-		},
-		{
-			name: "noop - high new blocks",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{height: 5, items: []pcBlock{{"P1", 30}, {"P2", 31}}}, event: rProcessBlock{},
-					wantState: &params{height: 5, items: []pcBlock{{"P1", 30}, {"P2", 31}}}, wantNextEvent: noOp,
-				},
-			},
-		},
-		{
-			name: "blocks H+1 and H+2 present",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}}, event: rProcessBlock{},
-					wantState:     &params{height: 1, items: []pcBlock{{"P2", 2}}, blocksSynced: 1},
-					wantNextEvent: pcBlockProcessed{height: 1, peerID: "P1"},
-				},
-			},
-		},
-		{
-			name: "blocks H+1 and H+2 present after draining",
-			steps: []pcFsmMakeStateValues{
-				{ // some contiguous blocks - on stop check draining is set
-					currentState:  &params{items: []pcBlock{{"P1", 1}, {"P2", 2}, {"P1", 4}}},
-					event:         scFinishedEv{},
-					wantState:     &params{items: []pcBlock{{"P1", 1}, {"P2", 2}, {"P1", 4}}, draining: true},
-					wantNextEvent: noOp,
-				},
-				{
-					event:         rProcessBlock{},
-					wantState:     &params{height: 1, items: []pcBlock{{"P2", 2}, {"P1", 4}}, blocksSynced: 1, draining: true},
-					wantNextEvent: pcBlockProcessed{height: 1, peerID: "P1"},
-				},
-				{ // finish when H+1 or/and H+2 are missing
-					event:         rProcessBlock{},
-					wantState:     &params{height: 1, items: []pcBlock{{"P2", 2}, {"P1", 4}}, blocksSynced: 1, draining: true},
-					wantNextEvent: pcFinished{tmState: tmstate.State{LastBlockHeight: 1}, blocksSynced: 1},
-				},
-			},
-		},
-	}
-
-	executeProcessorTests(t, tests)
-}
-
-func TestRProcessBlockFailures(t *testing.T) {
-	tests := []testFields{
-		{
-			name: "blocks H+1 and H+2 present from different peers - H+1 verification fails ",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}, verBL: []int64{1}}, event: rProcessBlock{},
-					wantState:     &params{items: []pcBlock{}, verBL: []int64{1}},
-					wantNextEvent: pcBlockVerificationFailure{height: 1, firstPeerID: "P1", secondPeerID: "P2"},
-				},
-			},
-		},
-		{
-			name: "blocks H+1 and H+2 present from same peer - H+1 applyBlock fails ",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}}, appBL: []int64{1}}, event: rProcessBlock{},
-					wantState: &params{items: []pcBlock{}, appBL: []int64{1}}, wantPanic: true,
-				},
-			},
-		},
-		{
-			name: "blocks H+1 and H+2 present from same peers - H+1 verification fails ",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{height: 0, items: []pcBlock{{"P1", 1}, {"P1", 2}, {"P2", 3}},
-						verBL: []int64{1}}, event: rProcessBlock{},
-					wantState:     &params{height: 0, items: []pcBlock{{"P2", 3}}, verBL: []int64{1}},
-					wantNextEvent: pcBlockVerificationFailure{height: 1, firstPeerID: "P1", secondPeerID: "P1"},
-				},
-			},
-		},
-		{
-			name: "blocks H+1 and H+2 present from different peers - H+1 applyBlock fails ",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{items: []pcBlock{{"P1", 1}, {"P2", 2}, {"P2", 3}}, appBL: []int64{1}},
-					event:        rProcessBlock{},
-					wantState:    &params{items: []pcBlock{{"P2", 3}}, appBL: []int64{1}}, wantPanic: true,
-				},
-			},
-		},
-	}
-
-	executeProcessorTests(t, tests)
-}
-
-func TestScFinishedEv(t *testing.T) {
-	tests := []testFields{
-		{
-			name: "no blocks",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{height: 100, items: []pcBlock{}, blocksSynced: 100}, event: scFinishedEv{},
-					wantState:     &params{height: 100, items: []pcBlock{}, blocksSynced: 100},
-					wantNextEvent: pcFinished{tmState: tmstate.State{LastBlockHeight: 100}, blocksSynced: 100},
-				},
-			},
-		},
-		{
-			name: "maxHeight+1 block present",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{height: 100, items: []pcBlock{
-						{"P1", 101}}, blocksSynced: 100}, event: scFinishedEv{},
-					wantState:     &params{height: 100, items: []pcBlock{{"P1", 101}}, blocksSynced: 100},
-					wantNextEvent: pcFinished{tmState: tmstate.State{LastBlockHeight: 100}, blocksSynced: 100},
-				},
-			},
-		},
-		{
-			name: "more blocks present",
-			steps: []pcFsmMakeStateValues{
-				{
-					currentState: &params{height: 100, items: []pcBlock{
-						{"P1", 101}, {"P1", 102}}, blocksSynced: 100}, event: scFinishedEv{},
-					wantState: &params{height: 100, items: []pcBlock{
-						{"P1", 101}, {"P1", 102}}, blocksSynced: 100, draining: true},
-					wantNextEvent: noOp,
-					wantErr:       nil,
-				},
-			},
-		},
-	}
-
-	executeProcessorTests(t, tests)
-}
diff --git a/internal/blocksync/v2/reactor.go b/internal/blocksync/v2/reactor.go
deleted file mode 100644
index f8dcbcf64b..0000000000
--- a/internal/blocksync/v2/reactor.go
+++ /dev/null
@@ -1,643 +0,0 @@
-package v2
-
-import (
-	"errors"
-	"fmt"
-	"time"
-
-	"github.com/gogo/protobuf/proto"
-
-	"github.com/tendermint/tendermint/internal/blocksync"
-	"github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior"
-	"github.com/tendermint/tendermint/internal/consensus"
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/state"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/libs/sync"
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	// chBufferSize is the buffer size of all event channels.
-	chBufferSize int = 1000
-)
-
-type blockStore interface {
-	LoadBlock(height int64) *types.Block
-	SaveBlock(*types.Block, *types.PartSet, *types.Commit)
-	Base() int64
-	Height() int64
-}
-
-// BlockchainReactor handles block sync protocol.
-type BlockchainReactor struct {
-	p2p.BaseReactor
-
-	blockSync   *sync.AtomicBool // enable block sync on start when it's been Set
-	stateSynced bool             // set to true when SwitchToBlockSync is called by state sync
-	scheduler   *Routine
-	processor   *Routine
-	logger      log.Logger
-
-	mtx           tmsync.RWMutex
-	maxPeerHeight int64
-	syncHeight    int64
-	events        chan Event // non-nil during a block sync
-
-	reporter behavior.Reporter
-	io       iIO
-	store    blockStore
-
-	syncStartTime   time.Time
-	syncStartHeight int64
-	lastSyncRate    float64 // # blocks sync per sec base on the last 100 blocks
-}
-
-type blockApplier interface {
-	ApplyBlock(state state.State, blockID types.BlockID, block *types.Block) (state.State, error)
-}
-
-// XXX: unify naming in this package around tmState
-func newReactor(state state.State, store blockStore, reporter behavior.Reporter,
-	blockApplier blockApplier, blockSync bool, metrics *consensus.Metrics) *BlockchainReactor {
-	initHeight := state.LastBlockHeight + 1
-	if initHeight == 1 {
-		initHeight = state.InitialHeight
-	}
-	scheduler := newScheduler(initHeight, time.Now())
-	pContext := newProcessorContext(store, blockApplier, state, metrics)
-	// TODO: Fix naming to just newProcesssor
-	// newPcState requires a processorContext
-	processor := newPcState(pContext)
-
-	return &BlockchainReactor{
-		scheduler:       newRoutine("scheduler", scheduler.handle, chBufferSize),
-		processor:       newRoutine("processor", processor.handle, chBufferSize),
-		store:           store,
-		reporter:        reporter,
-		logger:          log.NewNopLogger(),
-		blockSync:       sync.NewBool(blockSync),
-		syncStartHeight: initHeight,
-		syncStartTime:   time.Time{},
-		lastSyncRate:    0,
-	}
-}
-
-// NewBlockchainReactor creates a new reactor instance.
-func NewBlockchainReactor(
-	state state.State,
-	blockApplier blockApplier,
-	store blockStore,
-	blockSync bool,
-	metrics *consensus.Metrics) *BlockchainReactor {
-	reporter := behavior.NewMockReporter()
-	return newReactor(state, store, reporter, blockApplier, blockSync, metrics)
-}
-
-// SetSwitch implements Reactor interface.
-func (r *BlockchainReactor) SetSwitch(sw *p2p.Switch) {
-	r.Switch = sw
-	if sw != nil {
-		r.io = newSwitchIo(sw)
-	} else {
-		r.io = nil
-	}
-}
-
-func (r *BlockchainReactor) setMaxPeerHeight(height int64) {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	if height > r.maxPeerHeight {
-		r.maxPeerHeight = height
-	}
-}
-
-func (r *BlockchainReactor) setSyncHeight(height int64) {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	r.syncHeight = height
-}
-
-// SyncHeight returns the height to which the BlockchainReactor has synced.
-func (r *BlockchainReactor) SyncHeight() int64 {
-	r.mtx.RLock()
-	defer r.mtx.RUnlock()
-	return r.syncHeight
-}
-
-// SetLogger sets the logger of the reactor.
-func (r *BlockchainReactor) SetLogger(logger log.Logger) {
-	r.logger = logger
-	r.scheduler.setLogger(logger)
-	r.processor.setLogger(logger)
-}
-
-// Start implements cmn.Service interface
-func (r *BlockchainReactor) Start() error {
-	r.reporter = behavior.NewSwitchReporter(r.BaseReactor.Switch)
-	if r.blockSync.IsSet() {
-		err := r.startSync(nil)
-		if err != nil {
-			return fmt.Errorf("failed to start block sync: %w", err)
-		}
-	}
-	return nil
-}
-
-// startSync begins a block sync, signaled by r.events being non-nil. If state is non-nil,
-// the scheduler and processor is updated with this state on startup.
-func (r *BlockchainReactor) startSync(state *state.State) error {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	if r.events != nil {
-		return errors.New("block sync already in progress")
-	}
-	r.events = make(chan Event, chBufferSize)
-	go r.scheduler.start()
-	go r.processor.start()
-	if state != nil {
-		<-r.scheduler.ready()
-		<-r.processor.ready()
-		r.scheduler.send(bcResetState{state: *state})
-		r.processor.send(bcResetState{state: *state})
-	}
-	go r.demux(r.events)
-	return nil
-}
-
-// endSync ends a block sync
-func (r *BlockchainReactor) endSync() {
-	r.mtx.Lock()
-	defer r.mtx.Unlock()
-	if r.events != nil {
-		close(r.events)
-	}
-	r.events = nil
-	r.scheduler.stop()
-	r.processor.stop()
-}
-
-// SwitchToBlockSync is called by the state sync reactor when switching to block sync.
-func (r *BlockchainReactor) SwitchToBlockSync(state state.State) error {
-	r.stateSynced = true
-	state = state.Copy()
-
-	err := r.startSync(&state)
-	if err == nil {
-		r.syncStartTime = time.Now()
-	}
-
-	return err
-}
-
-// reactor generated ticker events:
-// ticker for cleaning peers
-type rTryPrunePeer struct {
-	priorityHigh
-	time time.Time
-}
-
-func (e rTryPrunePeer) String() string {
-	return fmt.Sprintf("rTryPrunePeer{%v}", e.time)
-}
-
-// ticker event for scheduling block requests
-type rTrySchedule struct {
-	priorityHigh
-	time time.Time
-}
-
-func (e rTrySchedule) String() string {
-	return fmt.Sprintf("rTrySchedule{%v}", e.time)
-}
-
-// ticker for block processing
-type rProcessBlock struct {
-	priorityNormal
-}
-
-func (e rProcessBlock) String() string {
-	return "rProcessBlock"
-}
-
-// reactor generated events based on blockchain related messages from peers:
-// blockResponse message received from a peer
-type bcBlockResponse struct {
-	priorityNormal
-	time   time.Time
-	peerID types.NodeID
-	size   int64
-	block  *types.Block
-}
-
-func (resp bcBlockResponse) String() string {
-	return fmt.Sprintf("bcBlockResponse{%d#%X (size: %d bytes) from %v at %v}",
-		resp.block.Height, resp.block.Hash(), resp.size, resp.peerID, resp.time)
-}
-
-// blockNoResponse message received from a peer
-type bcNoBlockResponse struct {
-	priorityNormal
-	time   time.Time
-	peerID types.NodeID
-	height int64
-}
-
-func (resp bcNoBlockResponse) String() string {
-	return fmt.Sprintf("bcNoBlockResponse{%v has no block at height %d at %v}",
-		resp.peerID, resp.height, resp.time)
-}
-
-// statusResponse message received from a peer
-type bcStatusResponse struct {
-	priorityNormal
-	time   time.Time
-	peerID types.NodeID
-	base   int64
-	height int64
-}
-
-func (resp bcStatusResponse) String() string {
-	return fmt.Sprintf("bcStatusResponse{%v is at height %d (base: %d) at %v}",
-		resp.peerID, resp.height, resp.base, resp.time)
-}
-
-// new peer is connected
-type bcAddNewPeer struct {
-	priorityNormal
-	peerID types.NodeID
-}
-
-func (resp bcAddNewPeer) String() string {
-	return fmt.Sprintf("bcAddNewPeer{%v}", resp.peerID)
-}
-
-// existing peer is removed
-type bcRemovePeer struct {
-	priorityHigh
-	peerID types.NodeID
-	reason interface{}
-}
-
-func (resp bcRemovePeer) String() string {
-	return fmt.Sprintf("bcRemovePeer{%v due to %v}", resp.peerID, resp.reason)
-}
-
-// resets the scheduler and processor state, e.g. following a switch from state syncing
-type bcResetState struct {
-	priorityHigh
-	state state.State
-}
-
-func (e bcResetState) String() string {
-	return fmt.Sprintf("bcResetState{%v}", e.state)
-}
-
-// Takes the channel as a parameter to avoid race conditions on r.events.
-func (r *BlockchainReactor) demux(events <-chan Event) {
-	var lastHundred = time.Now()
-
-	var (
-		processBlockFreq = 20 * time.Millisecond
-		doProcessBlockCh = make(chan struct{}, 1)
-		doProcessBlockTk = time.NewTicker(processBlockFreq)
-	)
-	defer doProcessBlockTk.Stop()
-
-	var (
-		prunePeerFreq = 1 * time.Second
-		doPrunePeerCh = make(chan struct{}, 1)
-		doPrunePeerTk = time.NewTicker(prunePeerFreq)
-	)
-	defer doPrunePeerTk.Stop()
-
-	var (
-		scheduleFreq = 20 * time.Millisecond
-		doScheduleCh = make(chan struct{}, 1)
-		doScheduleTk = time.NewTicker(scheduleFreq)
-	)
-	defer doScheduleTk.Stop()
-
-	var (
-		statusFreq = 10 * time.Second
-		doStatusCh = make(chan struct{}, 1)
-		doStatusTk = time.NewTicker(statusFreq)
-	)
-	defer doStatusTk.Stop()
-	doStatusCh <- struct{}{} // immediately broadcast to get status of existing peers
-
-	// Memoize the scSchedulerFail error to avoid printing it every scheduleFreq.
-	var scSchedulerFailErr error
-
-	// XXX: Extract timers to make testing atemporal
-	for {
-		select {
-		// Pacers: send at most per frequency but don't saturate
-		case <-doProcessBlockTk.C:
-			select {
-			case doProcessBlockCh <- struct{}{}:
-			default:
-			}
-		case <-doPrunePeerTk.C:
-			select {
-			case doPrunePeerCh <- struct{}{}:
-			default:
-			}
-		case <-doScheduleTk.C:
-			select {
-			case doScheduleCh <- struct{}{}:
-			default:
-			}
-		case <-doStatusTk.C:
-			select {
-			case doStatusCh <- struct{}{}:
-			default:
-			}
-
-		// Tickers: perform tasks periodically
-		case <-doScheduleCh:
-			r.scheduler.send(rTrySchedule{time: time.Now()})
-		case <-doPrunePeerCh:
-			r.scheduler.send(rTryPrunePeer{time: time.Now()})
-		case <-doProcessBlockCh:
-			r.processor.send(rProcessBlock{})
-		case <-doStatusCh:
-			if err := r.io.broadcastStatusRequest(); err != nil {
-				r.logger.Error("Error broadcasting status request", "err", err)
-			}
-
-		// Events from peers. Closing the channel signals event loop termination.
-		case event, ok := <-events:
-			if !ok {
-				r.logger.Info("Stopping event processing")
-				return
-			}
-			switch event := event.(type) {
-			case bcStatusResponse:
-				r.setMaxPeerHeight(event.height)
-				r.scheduler.send(event)
-			case bcAddNewPeer, bcRemovePeer, bcBlockResponse, bcNoBlockResponse:
-				r.scheduler.send(event)
-			default:
-				r.logger.Error("Received unexpected event", "event", fmt.Sprintf("%T", event))
-			}
-
-		// Incremental events from scheduler
-		case event := <-r.scheduler.next():
-			switch event := event.(type) {
-			case scBlockReceived:
-				r.processor.send(event)
-			case scPeerError:
-				r.processor.send(event)
-				if err := r.reporter.Report(behavior.BadMessage(event.peerID, "scPeerError")); err != nil {
-					r.logger.Error("Error reporting peer", "err", err)
-				}
-			case scBlockRequest:
-				peer := r.Switch.Peers().Get(event.peerID)
-				if peer == nil {
-					r.logger.Error("Wanted to send block request, but no such peer", "peerID", event.peerID)
-					continue
-				}
-				if err := r.io.sendBlockRequest(peer, event.height); err != nil {
-					r.logger.Error("Error sending block request", "err", err)
-				}
-			case scFinishedEv:
-				r.processor.send(event)
-				r.scheduler.stop()
-			case scSchedulerFail:
-				if scSchedulerFailErr != event.reason {
-					r.logger.Error("Scheduler failure", "err", event.reason.Error())
-					scSchedulerFailErr = event.reason
-				}
-			case scPeersPruned:
-				// Remove peers from the processor.
-				for _, peerID := range event.peers {
-					r.processor.send(scPeerError{peerID: peerID, reason: errors.New("peer was pruned")})
-				}
-				r.logger.Debug("Pruned peers", "count", len(event.peers))
-			case noOpEvent:
-			default:
-				r.logger.Error("Received unexpected scheduler event", "event", fmt.Sprintf("%T", event))
-			}
-
-		// Incremental events from processor
-		case event := <-r.processor.next():
-			switch event := event.(type) {
-			case pcBlockProcessed:
-				r.setSyncHeight(event.height)
-				if (r.syncHeight-r.syncStartHeight)%100 == 0 {
-					newSyncRate := 100 / time.Since(lastHundred).Seconds()
-					if r.lastSyncRate == 0 {
-						r.lastSyncRate = newSyncRate
-					} else {
-						r.lastSyncRate = 0.9*r.lastSyncRate + 0.1*newSyncRate
-					}
-					r.logger.Info("block sync Rate", "height", r.syncHeight,
-						"max_peer_height", r.maxPeerHeight, "blocks/s", r.lastSyncRate)
-					lastHundred = time.Now()
-				}
-				r.scheduler.send(event)
-			case pcBlockVerificationFailure:
-				r.scheduler.send(event)
-			case pcFinished:
-				r.logger.Info("block sync complete, switching to consensus")
-				if !r.io.trySwitchToConsensus(event.tmState, event.blocksSynced > 0 || r.stateSynced) {
-					r.logger.Error("Failed to switch to consensus reactor")
-				}
-				r.endSync()
-				r.blockSync.UnSet()
-				return
-			case noOpEvent:
-			default:
-				r.logger.Error("Received unexpected processor event", "event", fmt.Sprintf("%T", event))
-			}
-
-		// Terminal event from scheduler
-		case err := <-r.scheduler.final():
-			switch err {
-			case nil:
-				r.logger.Info("Scheduler stopped")
-			default:
-				r.logger.Error("Scheduler aborted with error", "err", err)
-			}
-
-		// Terminal event from processor
-		case err := <-r.processor.final():
-			switch err {
-			case nil:
-				r.logger.Info("Processor stopped")
-			default:
-				r.logger.Error("Processor aborted with error", "err", err)
-			}
-		}
-	}
-}
-
-// Stop implements cmn.Service interface.
-func (r *BlockchainReactor) Stop() error {
-	r.logger.Info("reactor stopping")
-	r.endSync()
-	r.logger.Info("reactor stopped")
-	return nil
-}
-
-// Receive implements Reactor by handling different message types.
-// XXX: do not call any methods that can block or incur heavy processing.
-// https://github.com/tendermint/tendermint/issues/2888
-func (r *BlockchainReactor) Receive(chID byte, src p2p.Peer, msgBytes []byte) {
-	logger := r.logger.With("src", src.ID(), "chID", chID)
-
-	msgProto := new(bcproto.Message)
-
-	if err := proto.Unmarshal(msgBytes, msgProto); err != nil {
-		logger.Error("error decoding message", "err", err)
-		_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
-		return
-	}
-
-	if err := msgProto.Validate(); err != nil {
-		logger.Error("peer sent us an invalid msg", "msg", msgProto, "err", err)
-		_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
-		return
-	}
-
-	r.logger.Debug("received", "msg", msgProto)
-
-	switch msg := msgProto.Sum.(type) {
-	case *bcproto.Message_StatusRequest:
-		if err := r.io.sendStatusResponse(r.store.Base(), r.store.Height(), src); err != nil {
-			logger.Error("Could not send status message to src peer")
-		}
-
-	case *bcproto.Message_BlockRequest:
-		block := r.store.LoadBlock(msg.BlockRequest.Height)
-		if block != nil {
-			if err := r.io.sendBlockToPeer(block, src); err != nil {
-				logger.Error("Could not send block message to src peer", "err", err)
-			}
-		} else {
-			logger.Info("peer asking for a block we don't have", "height", msg.BlockRequest.Height)
-			if err := r.io.sendBlockNotFound(msg.BlockRequest.Height, src); err != nil {
-				logger.Error("Couldn't send block not found msg", "err", err)
-			}
-		}
-
-	case *bcproto.Message_StatusResponse:
-		r.mtx.RLock()
-		if r.events != nil {
-			r.events <- bcStatusResponse{
-				peerID: src.ID(),
-				base:   msg.StatusResponse.Base,
-				height: msg.StatusResponse.Height,
-			}
-		}
-		r.mtx.RUnlock()
-
-	case *bcproto.Message_BlockResponse:
-		bi, err := types.BlockFromProto(msg.BlockResponse.Block)
-		if err != nil {
-			logger.Error("error transitioning block from protobuf", "err", err)
-			_ = r.reporter.Report(behavior.BadMessage(src.ID(), err.Error()))
-			return
-		}
-		r.mtx.RLock()
-		if r.events != nil {
-			r.events <- bcBlockResponse{
-				peerID: src.ID(),
-				block:  bi,
-				size:   int64(len(msgBytes)),
-				time:   time.Now(),
-			}
-		}
-		r.mtx.RUnlock()
-
-	case *bcproto.Message_NoBlockResponse:
-		r.mtx.RLock()
-		if r.events != nil {
-			r.events <- bcNoBlockResponse{
-				peerID: src.ID(),
-				height: msg.NoBlockResponse.Height,
-				time:   time.Now(),
-			}
-		}
-		r.mtx.RUnlock()
-	}
-}
-
-// AddPeer implements Reactor interface
-func (r *BlockchainReactor) AddPeer(peer p2p.Peer) {
-	err := r.io.sendStatusResponse(r.store.Base(), r.store.Height(), peer)
-	if err != nil {
-		r.logger.Error("could not send our status to the new peer", "peer", peer.ID, "err", err)
-	}
-
-	err = r.io.sendStatusRequest(peer)
-	if err != nil {
-		r.logger.Error("could not send status request to the new peer", "peer", peer.ID, "err", err)
-	}
-
-	r.mtx.RLock()
-	defer r.mtx.RUnlock()
-	if r.events != nil {
-		r.events <- bcAddNewPeer{peerID: peer.ID()}
-	}
-}
-
-// RemovePeer implements Reactor interface.
-func (r *BlockchainReactor) RemovePeer(peer p2p.Peer, reason interface{}) {
-	r.mtx.RLock()
-	defer r.mtx.RUnlock()
-	if r.events != nil {
-		r.events <- bcRemovePeer{
-			peerID: peer.ID(),
-			reason: reason,
-		}
-	}
-}
-
-// GetChannels implements Reactor
-func (r *BlockchainReactor) GetChannels() []*p2p.ChannelDescriptor {
-	return []*p2p.ChannelDescriptor{
-		{
-			ID:                  BlockchainChannel,
-			Priority:            5,
-			SendQueueCapacity:   2000,
-			RecvBufferCapacity:  1024,
-			RecvMessageCapacity: blocksync.MaxMsgSize,
-		},
-	}
-}
-
-func (r *BlockchainReactor) GetMaxPeerBlockHeight() int64 {
-	r.mtx.RLock()
-	defer r.mtx.RUnlock()
-	return r.maxPeerHeight
-}
-
-func (r *BlockchainReactor) GetTotalSyncedTime() time.Duration {
-	if !r.blockSync.IsSet() || r.syncStartTime.IsZero() {
-		return time.Duration(0)
-	}
-	return time.Since(r.syncStartTime)
-}
-
-func (r *BlockchainReactor) GetRemainingSyncTime() time.Duration {
-	if !r.blockSync.IsSet() {
-		return time.Duration(0)
-	}
-
-	r.mtx.RLock()
-	defer r.mtx.RUnlock()
-
-	targetSyncs := r.maxPeerHeight - r.syncStartHeight
-	currentSyncs := r.syncHeight - r.syncStartHeight + 1
-	if currentSyncs < 0 || r.lastSyncRate < 0.001 {
-		return time.Duration(0)
-	}
-
-	remain := float64(targetSyncs-currentSyncs) / r.lastSyncRate
-
-	return time.Duration(int64(remain * float64(time.Second)))
-}
diff --git a/internal/blocksync/v2/reactor_test.go b/internal/blocksync/v2/reactor_test.go
deleted file mode 100644
index 579a46c199..0000000000
--- a/internal/blocksync/v2/reactor_test.go
+++ /dev/null
@@ -1,533 +0,0 @@
-package v2
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/gogo/protobuf/proto"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	dbm "github.com/tendermint/tm-db"
-
-	abciclient "github.com/tendermint/tendermint/abci/client"
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior"
-	"github.com/tendermint/tendermint/internal/consensus"
-	"github.com/tendermint/tendermint/internal/mempool/mock"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
-	"github.com/tendermint/tendermint/internal/proxy"
-	sm "github.com/tendermint/tendermint/internal/state"
-	sf "github.com/tendermint/tendermint/internal/state/test/factory"
-	tmstore "github.com/tendermint/tendermint/internal/store"
-	"github.com/tendermint/tendermint/internal/test/factory"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/libs/service"
-	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
-	"github.com/tendermint/tendermint/types"
-)
-
-type mockPeer struct {
-	service.Service
-	id types.NodeID
-}
-
-func (mp mockPeer) FlushStop()           {}
-func (mp mockPeer) ID() types.NodeID     { return mp.id }
-func (mp mockPeer) RemoteIP() net.IP     { return net.IP{} }
-func (mp mockPeer) RemoteAddr() net.Addr { return &net.TCPAddr{IP: mp.RemoteIP(), Port: 8800} }
-
-func (mp mockPeer) IsOutbound() bool   { return true }
-func (mp mockPeer) IsPersistent() bool { return true }
-func (mp mockPeer) CloseConn() error   { return nil }
-
-func (mp mockPeer) NodeInfo() types.NodeInfo {
-	return types.NodeInfo{
-		NodeID:     "",
-		ListenAddr: "",
-	}
-}
-func (mp mockPeer) Status() conn.ConnectionStatus { return conn.ConnectionStatus{} }
-func (mp mockPeer) SocketAddr() *p2p.NetAddress   { return &p2p.NetAddress{} }
-
-func (mp mockPeer) Send(byte, []byte) bool    { return true }
-func (mp mockPeer) TrySend(byte, []byte) bool { return true }
-
-func (mp mockPeer) Set(string, interface{}) {}
-func (mp mockPeer) Get(string) interface{}  { return struct{}{} }
-
-//nolint:unused
-type mockBlockStore struct {
-	blocks map[int64]*types.Block
-}
-
-//nolint:unused
-func (ml *mockBlockStore) Height() int64 {
-	return int64(len(ml.blocks))
-}
-
-//nolint:unused
-func (ml *mockBlockStore) LoadBlock(height int64) *types.Block {
-	return ml.blocks[height]
-}
-
-//nolint:unused
-func (ml *mockBlockStore) SaveBlock(block *types.Block, part *types.PartSet, commit *types.Commit) {
-	ml.blocks[block.Height] = block
-}
-
-type mockBlockApplier struct {
-}
-
-// XXX: Add whitelist/blacklist?
-func (mba *mockBlockApplier) ApplyBlock(
-	state sm.State, blockID types.BlockID, block *types.Block,
-) (sm.State, error) {
-	state.LastBlockHeight++
-	return state, nil
-}
-
-type mockSwitchIo struct {
-	mtx                 sync.Mutex
-	switchedToConsensus bool
-	numStatusResponse   int
-	numBlockResponse    int
-	numNoBlockResponse  int
-	numStatusRequest    int
-}
-
-var _ iIO = (*mockSwitchIo)(nil)
-
-func (sio *mockSwitchIo) sendBlockRequest(_ p2p.Peer, _ int64) error {
-	return nil
-}
-
-func (sio *mockSwitchIo) sendStatusResponse(_, _ int64, _ p2p.Peer) error {
-	sio.mtx.Lock()
-	defer sio.mtx.Unlock()
-	sio.numStatusResponse++
-	return nil
-}
-
-func (sio *mockSwitchIo) sendBlockToPeer(_ *types.Block, _ p2p.Peer) error {
-	sio.mtx.Lock()
-	defer sio.mtx.Unlock()
-	sio.numBlockResponse++
-	return nil
-}
-
-func (sio *mockSwitchIo) sendBlockNotFound(_ int64, _ p2p.Peer) error {
-	sio.mtx.Lock()
-	defer sio.mtx.Unlock()
-	sio.numNoBlockResponse++
-	return nil
-}
-
-func (sio *mockSwitchIo) trySwitchToConsensus(_ sm.State, _ bool) bool {
-	sio.mtx.Lock()
-	defer sio.mtx.Unlock()
-	sio.switchedToConsensus = true
-	return true
-}
-
-func (sio *mockSwitchIo) broadcastStatusRequest() error {
-	return nil
-}
-
-func (sio *mockSwitchIo) sendStatusRequest(_ p2p.Peer) error {
-	sio.mtx.Lock()
-	defer sio.mtx.Unlock()
-	sio.numStatusRequest++
-	return nil
-}
-
-type testReactorParams struct {
-	logger      log.Logger
-	genDoc      *types.GenesisDoc
-	privVals    []types.PrivValidator
-	startHeight int64
-	mockA       bool
-}
-
-func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
-	store, state, _ := newReactorStore(t, p.genDoc, p.privVals, p.startHeight)
-	reporter := behavior.NewMockReporter()
-
-	var appl blockApplier
-
-	if p.mockA {
-		appl = &mockBlockApplier{}
-	} else {
-		app := &testApp{}
-		cc := abciclient.NewLocalCreator(app)
-		proxyApp := proxy.NewAppConns(cc)
-		err := proxyApp.Start()
-		require.NoError(t, err)
-		db := dbm.NewMemDB()
-		stateStore := sm.NewStore(db)
-		blockStore := tmstore.NewBlockStore(dbm.NewMemDB())
-		appl = sm.NewBlockExecutor(
-			stateStore, p.logger, proxyApp.Consensus(), mock.Mempool{}, sm.EmptyEvidencePool{}, blockStore)
-		err = stateStore.Save(state)
-		require.NoError(t, err)
-	}
-
-	r := newReactor(state, store, reporter, appl, true, consensus.NopMetrics())
-	logger := log.TestingLogger()
-	r.SetLogger(logger.With("module", "blockchain"))
-
-	return r
-}
-
-// This test is left here and not deleted to retain the termination cases for
-// future improvement in [#4482](https://github.com/tendermint/tendermint/issues/4482).
-// func TestReactorTerminationScenarios(t *testing.T) {
-
-//	config := cfg.ResetTestRoot("blockchain_reactor_v2_test")
-//	defer os.RemoveAll(config.RootDir)
-//	genDoc, privVals := randGenesisDoc(config.ChainID(), 1, false, 30)
-//	refStore, _, _ := newReactorStore(genDoc, privVals, 20)
-
-//	params := testReactorParams{
-//		logger:      log.TestingLogger(),
-//		genDoc:      genDoc,
-//		privVals:    privVals,
-//		startHeight: 10,
-//		bufferSize:  100,
-//		mockA:       true,
-//	}
-
-//	type testEvent struct {
-//		evType string
-//		peer   string
-//		height int64
-//	}
-
-//	tests := []struct {
-//		name   string
-//		params testReactorParams
-//		msgs   []testEvent
-//	}{
-//		{
-//			name:   "simple termination on max peer height - one peer",
-//			params: params,
-//			msgs: []testEvent{
-//				{evType: "AddPeer", peer: "P1"},
-//				{evType: "ReceiveS", peer: "P1", height: 13},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P1", height: 11},
-//				{evType: "BlockReq"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P1", height: 12},
-//				{evType: "Process"},
-//				{evType: "ReceiveB", peer: "P1", height: 13},
-//				{evType: "Process"},
-//			},
-//		},
-//		{
-//			name:   "simple termination on max peer height - two peers",
-//			params: params,
-//			msgs: []testEvent{
-//				{evType: "AddPeer", peer: "P1"},
-//				{evType: "AddPeer", peer: "P2"},
-//				{evType: "ReceiveS", peer: "P1", height: 13},
-//				{evType: "ReceiveS", peer: "P2", height: 15},
-//				{evType: "BlockReq"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P1", height: 11},
-//				{evType: "ReceiveB", peer: "P2", height: 12},
-//				{evType: "Process"},
-//				{evType: "BlockReq"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P1", height: 13},
-//				{evType: "Process"},
-//				{evType: "ReceiveB", peer: "P2", height: 14},
-//				{evType: "Process"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P2", height: 15},
-//				{evType: "Process"},
-//			},
-//		},
-//		{
-//			name:   "termination on max peer height - two peers, noBlock error",
-//			params: params,
-//			msgs: []testEvent{
-//				{evType: "AddPeer", peer: "P1"},
-//				{evType: "AddPeer", peer: "P2"},
-//				{evType: "ReceiveS", peer: "P1", height: 13},
-//				{evType: "ReceiveS", peer: "P2", height: 15},
-//				{evType: "BlockReq"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveNB", peer: "P1", height: 11},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P2", height: 12},
-//				{evType: "ReceiveB", peer: "P2", height: 11},
-//				{evType: "Process"},
-//				{evType: "BlockReq"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P2", height: 13},
-//				{evType: "Process"},
-//				{evType: "ReceiveB", peer: "P2", height: 14},
-//				{evType: "Process"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P2", height: 15},
-//				{evType: "Process"},
-//			},
-//		},
-//		{
-//			name:   "termination on max peer height - two peers, remove one peer",
-//			params: params,
-//			msgs: []testEvent{
-//				{evType: "AddPeer", peer: "P1"},
-//				{evType: "AddPeer", peer: "P2"},
-//				{evType: "ReceiveS", peer: "P1", height: 13},
-//				{evType: "ReceiveS", peer: "P2", height: 15},
-//				{evType: "BlockReq"},
-//				{evType: "BlockReq"},
-//				{evType: "RemovePeer", peer: "P1"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P2", height: 12},
-//				{evType: "ReceiveB", peer: "P2", height: 11},
-//				{evType: "Process"},
-//				{evType: "BlockReq"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P2", height: 13},
-//				{evType: "Process"},
-//				{evType: "ReceiveB", peer: "P2", height: 14},
-//				{evType: "Process"},
-//				{evType: "BlockReq"},
-//				{evType: "ReceiveB", peer: "P2", height: 15},
-//				{evType: "Process"},
-//			},
-//		},
-//	}
-
-//	for _, tt := range tests {
-//		tt := tt
-//		t.Run(tt.name, func(t *testing.T) {
-//			reactor := newTestReactor(params)
-//			reactor.Start()
-//			reactor.reporter = behavior.NewMockReporter()
-//			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
-//			reactor.io = mockSwitch
-//			// time for go routines to start
-//			time.Sleep(time.Millisecond)
-
-//			for _, step := range tt.msgs {
-//				switch step.evType {
-//				case "AddPeer":
-//					reactor.scheduler.send(bcAddNewPeer{peerID: p2p.ID(step.peer)})
-//				case "RemovePeer":
-//					reactor.scheduler.send(bcRemovePeer{peerID: p2p.ID(step.peer)})
-//				case "ReceiveS":
-//					reactor.scheduler.send(bcStatusResponse{
-//						peerID: p2p.ID(step.peer),
-//						height: step.height,
-//						time:   time.Now(),
-//					})
-//				case "ReceiveB":
-//					reactor.scheduler.send(bcBlockResponse{
-//						peerID: p2p.ID(step.peer),
-//						block:  refStore.LoadBlock(step.height),
-//						size:   10,
-//						time:   time.Now(),
-//					})
-//				case "ReceiveNB":
-//					reactor.scheduler.send(bcNoBlockResponse{
-//						peerID: p2p.ID(step.peer),
-//						height: step.height,
-//						time:   time.Now(),
-//					})
-//				case "BlockReq":
-//					reactor.scheduler.send(rTrySchedule{time: time.Now()})
-//				case "Process":
-//					reactor.processor.send(rProcessBlock{})
-//				}
-//				// give time for messages to propagate between routines
-//				time.Sleep(time.Millisecond)
-//			}
-
-//			// time for processor to finish and reactor to switch to consensus
-//			time.Sleep(20 * time.Millisecond)
-//			assert.True(t, mockSwitch.hasSwitchedToConsensus())
-//			reactor.Stop()
-//		})
-//	}
-// }
-
-func TestReactorHelperMode(t *testing.T) {
-	var (
-		channelID = byte(0x40)
-	)
-
-	cfg := config.ResetTestRoot("blockchain_reactor_v2_test")
-	defer os.RemoveAll(cfg.RootDir)
-	genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30)
-
-	params := testReactorParams{
-		logger:      log.TestingLogger(),
-		genDoc:      genDoc,
-		privVals:    privVals,
-		startHeight: 20,
-		mockA:       true,
-	}
-
-	type testEvent struct {
-		peer  string
-		event interface{}
-	}
-
-	tests := []struct {
-		name   string
-		params testReactorParams
-		msgs   []testEvent
-	}{
-		{
-			name:   "status request",
-			params: params,
-			msgs: []testEvent{
-				{"P1", bcproto.StatusRequest{}},
-				{"P1", bcproto.BlockRequest{Height: 13}},
-				{"P1", bcproto.BlockRequest{Height: 20}},
-				{"P1", bcproto.BlockRequest{Height: 22}},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			reactor := newTestReactor(t, params)
-			mockSwitch := &mockSwitchIo{switchedToConsensus: false}
-			reactor.io = mockSwitch
-			err := reactor.Start()
-			require.NoError(t, err)
-
-			for i := 0; i < len(tt.msgs); i++ {
-				step := tt.msgs[i]
-				switch ev := step.event.(type) {
-				case bcproto.StatusRequest:
-					old := mockSwitch.numStatusResponse
-
-					msgProto := new(bcproto.Message)
-					require.NoError(t, msgProto.Wrap(&ev))
-
-					msgBz, err := proto.Marshal(msgProto)
-					require.NoError(t, err)
-
-					reactor.Receive(channelID, mockPeer{id: types.NodeID(step.peer)}, msgBz)
-					assert.Equal(t, old+1, mockSwitch.numStatusResponse)
-				case bcproto.BlockRequest:
-					if ev.Height > params.startHeight {
-						old := mockSwitch.numNoBlockResponse
-
-						msgProto := new(bcproto.Message)
-						require.NoError(t, msgProto.Wrap(&ev))
-
-						msgBz, err := proto.Marshal(msgProto)
-						require.NoError(t, err)
-
-						reactor.Receive(channelID, mockPeer{id: types.NodeID(step.peer)}, msgBz)
-						assert.Equal(t, old+1, mockSwitch.numNoBlockResponse)
-					} else {
-						old := mockSwitch.numBlockResponse
-
-						msgProto := new(bcproto.Message)
-						require.NoError(t, msgProto.Wrap(&ev))
-
-						msgBz, err := proto.Marshal(msgProto)
-						require.NoError(t, err)
-
-						reactor.Receive(channelID, mockPeer{id: types.NodeID(step.peer)}, msgBz)
-						assert.Equal(t, old+1, mockSwitch.numBlockResponse)
-					}
-				}
-			}
-			err = reactor.Stop()
-			require.NoError(t, err)
-		})
-	}
-}
-
-func TestReactorSetSwitchNil(t *testing.T) {
-	cfg := config.ResetTestRoot("blockchain_reactor_v2_test")
-	defer os.RemoveAll(cfg.RootDir)
-	genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30)
-
-	reactor := newTestReactor(t, testReactorParams{
-		logger:   log.TestingLogger(),
-		genDoc:   genDoc,
-		privVals: privVals,
-	})
-	reactor.SetSwitch(nil)
-
-	assert.Nil(t, reactor.Switch)
-	assert.Nil(t, reactor.io)
-}
-
-type testApp struct {
-	abci.BaseApplication
-}
-
-func newReactorStore(
-	t *testing.T,
-	genDoc *types.GenesisDoc,
-	privVals []types.PrivValidator,
-	maxBlockHeight int64) (*tmstore.BlockStore, sm.State, *sm.BlockExecutor) {
-	t.Helper()
-
-	require.Len(t, privVals, 1)
-	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
-	err := proxyApp.Start()
-	if err != nil {
-		panic(fmt.Errorf("error start app: %w", err))
-	}
-
-	stateDB := dbm.NewMemDB()
-	blockStore := tmstore.NewBlockStore(dbm.NewMemDB())
-	stateStore := sm.NewStore(stateDB)
-	state, err := sm.MakeGenesisState(genDoc)
-	require.NoError(t, err)
-
-	blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(),
-		mock.Mempool{}, sm.EmptyEvidencePool{}, blockStore)
-	err = stateStore.Save(state)
-	require.NoError(t, err)
-
-	// add blocks in
-	for blockHeight := int64(1); blockHeight <= maxBlockHeight; blockHeight++ {
-		lastCommit := types.NewCommit(blockHeight-1, 0, types.BlockID{}, nil)
-		if blockHeight > 1 {
-			lastBlockMeta := blockStore.LoadBlockMeta(blockHeight - 1)
-			lastBlock := blockStore.LoadBlock(blockHeight - 1)
-			vote, err := factory.MakeVote(
-				privVals[0],
-				lastBlock.Header.ChainID, 0,
-				lastBlock.Header.Height, 0, 2,
-				lastBlockMeta.BlockID,
-				time.Now(),
-			)
-			require.NoError(t, err)
-			lastCommit = types.NewCommit(vote.Height, vote.Round,
-				lastBlockMeta.BlockID, []types.CommitSig{vote.CommitSig()})
-		}
-
-		thisBlock := sf.MakeBlock(state, blockHeight, lastCommit)
-
-		thisParts := thisBlock.MakePartSet(types.BlockPartSizeBytes)
-		blockID := types.BlockID{Hash: thisBlock.Hash(), PartSetHeader: thisParts.Header()}
-
-		state, err = blockExec.ApplyBlock(state, blockID, thisBlock)
-		require.NoError(t, err)
-
-		blockStore.SaveBlock(thisBlock, thisParts, lastCommit)
-	}
-	return blockStore, state, blockExec
-}
diff --git a/internal/blocksync/v2/routine.go b/internal/blocksync/v2/routine.go
deleted file mode 100644
index e4ca52add7..0000000000
--- a/internal/blocksync/v2/routine.go
+++ /dev/null
@@ -1,166 +0,0 @@
-package v2
-
-import (
-	"fmt"
-	"strings"
-	"sync/atomic"
-
-	"github.com/Workiva/go-datastructures/queue"
-
-	"github.com/tendermint/tendermint/libs/log"
-)
-
-type handleFunc = func(event Event) (Event, error)
-
-const historySize = 25
-
-// Routine is a structure that models a finite state machine as serialized
-// stream of events processed by a handle function. This Routine structure
-// handles the concurrency and messaging guarantees. Events are sent via
-// `send` are handled by the `handle` function to produce an iterator
-// `next()`. Calling `stop()` on a routine will conclude processing of all
-// sent events and produce `final()` event representing the terminal state.
-type Routine struct {
-	name    string
-	handle  handleFunc
-	queue   *queue.PriorityQueue
-	history []Event
-	out     chan Event
-	fin     chan error
-	rdy     chan struct{}
-	running *uint32
-	logger  log.Logger
-	metrics *Metrics
-}
-
-func newRoutine(name string, handleFunc handleFunc, bufferSize int) *Routine {
-	return &Routine{
-		name:    name,
-		handle:  handleFunc,
-		queue:   queue.NewPriorityQueue(bufferSize, true),
-		history: make([]Event, 0, historySize),
-		out:     make(chan Event, bufferSize),
-		rdy:     make(chan struct{}, 1),
-		fin:     make(chan error, 1),
-		running: new(uint32),
-		logger:  log.NewNopLogger(),
-		metrics: NopMetrics(),
-	}
-}
-
-func (rt *Routine) setLogger(logger log.Logger) {
-	rt.logger = logger
-}
-
-// nolint:unused
-func (rt *Routine) setMetrics(metrics *Metrics) {
-	rt.metrics = metrics
-}
-
-func (rt *Routine) start() {
-	rt.logger.Info(fmt.Sprintf("%s: run", rt.name))
-	running := atomic.CompareAndSwapUint32(rt.running, uint32(0), uint32(1))
-	if !running {
-		panic(fmt.Sprintf("%s is already running", rt.name))
-	}
-	close(rt.rdy)
-	defer func() {
-		if r := recover(); r != nil {
-			var (
-				b strings.Builder
-				j int
-			)
-			for i := len(rt.history) - 1; i >= 0; i-- {
-				fmt.Fprintf(&b, "%d: %+v\n", j, rt.history[i])
-				j++
-			}
-			panic(fmt.Sprintf("%v\nlast events:\n%v", r, b.String()))
-		}
-		stopped := atomic.CompareAndSwapUint32(rt.running, uint32(1), uint32(0))
-		if !stopped {
-			panic(fmt.Sprintf("%s is failed to stop", rt.name))
-		}
-	}()
-
-	for {
-		events, err := rt.queue.Get(1)
-		if err == queue.ErrDisposed {
-			rt.terminate(nil)
-			return
-		} else if err != nil {
-			rt.terminate(err)
-			return
-		}
-		oEvent, err := rt.handle(events[0].(Event))
-		rt.metrics.EventsHandled.With("routine", rt.name).Add(1)
-		if err != nil {
-			rt.terminate(err)
-			return
-		}
-		rt.metrics.EventsOut.With("routine", rt.name).Add(1)
-		rt.logger.Debug(fmt.Sprintf("%s: produced %T %+v", rt.name, oEvent, oEvent))
-
-		// Skip rTrySchedule and rProcessBlock events as they clutter the history
-		// due to their frequency.
-		switch events[0].(type) {
-		case rTrySchedule:
-		case rProcessBlock:
-		default:
-			rt.history = append(rt.history, events[0].(Event))
-			if len(rt.history) > historySize {
-				rt.history = rt.history[1:]
-			}
-		}
-
-		rt.out <- oEvent
-	}
-}
-
-// XXX: look into returning OpError in the net package
-func (rt *Routine) send(event Event) bool {
-	rt.logger.Debug(fmt.Sprintf("%s: received %T %+v", rt.name, event, event))
-	if !rt.isRunning() {
-		return false
-	}
-	err := rt.queue.Put(event)
-	if err != nil {
-		rt.metrics.EventsShed.With("routine", rt.name).Add(1)
-		rt.logger.Error(fmt.Sprintf("%s: send failed, queue was full/stopped", rt.name))
-		return false
-	}
-
-	rt.metrics.EventsSent.With("routine", rt.name).Add(1)
-	return true
-}
-
-func (rt *Routine) isRunning() bool {
-	return atomic.LoadUint32(rt.running) == 1
-}
-
-func (rt *Routine) next() chan Event {
-	return rt.out
-}
-
-func (rt *Routine) ready() chan struct{} {
-	return rt.rdy
-}
-
-func (rt *Routine) stop() {
-	if !rt.isRunning() { // XXX: this should check rt.queue.Disposed()
-		return
-	}
-
-	rt.logger.Info(fmt.Sprintf("%s: stop", rt.name))
-	rt.queue.Dispose() // this should block until all queue items are free?
-}
-
-func (rt *Routine) final() chan error {
-	return rt.fin
-}
-
-// XXX: Maybe get rid of this
-func (rt *Routine) terminate(reason error) {
-	// We don't close the rt.out channel here, to avoid spinning on the closed channel
-	// in the event loop.
-	rt.fin <- reason
-}
diff --git a/internal/blocksync/v2/routine_test.go b/internal/blocksync/v2/routine_test.go
deleted file mode 100644
index 8f92bee3ee..0000000000
--- a/internal/blocksync/v2/routine_test.go
+++ /dev/null
@@ -1,163 +0,0 @@
-package v2
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-type eventA struct {
-	priorityNormal
-}
-
-var errDone = fmt.Errorf("done")
-
-func simpleHandler(event Event) (Event, error) {
-	if _, ok := event.(eventA); ok {
-		return noOp, errDone
-	}
-	return noOp, nil
-}
-
-func TestRoutineFinal(t *testing.T) {
-	var (
-		bufferSize = 10
-		routine    = newRoutine("simpleRoutine", simpleHandler, bufferSize)
-	)
-
-	assert.False(t, routine.isRunning(),
-		"expected an initialized routine to not be running")
-	go routine.start()
-	<-routine.ready()
-	assert.True(t, routine.isRunning(),
-		"expected an started routine")
-
-	assert.True(t, routine.send(eventA{}),
-		"expected sending to a ready routine to succeed")
-
-	assert.Equal(t, errDone, <-routine.final(),
-		"expected the final event to be done")
-
-	assert.False(t, routine.isRunning(),
-		"expected an completed routine to no longer be running")
-}
-
-func TestRoutineStop(t *testing.T) {
-	var (
-		bufferSize = 10
-		routine    = newRoutine("simpleRoutine", simpleHandler, bufferSize)
-	)
-
-	assert.False(t, routine.send(eventA{}),
-		"expected sending to an unstarted routine to fail")
-
-	go routine.start()
-	<-routine.ready()
-
-	assert.True(t, routine.send(eventA{}),
-		"expected sending to a running routine to succeed")
-
-	routine.stop()
-
-	assert.False(t, routine.send(eventA{}),
-		"expected sending to a stopped routine to fail")
-}
-
-type finalCount struct {
-	count int
-}
-
-func (f finalCount) Error() string {
-	return "end"
-}
-
-func genStatefulHandler(maxCount int) handleFunc {
-	counter := 0
-	return func(event Event) (Event, error) {
-		if _, ok := event.(eventA); ok {
-			counter++
-			if counter >= maxCount {
-				return noOp, finalCount{counter}
-			}
-
-			return eventA{}, nil
-		}
-		return noOp, nil
-	}
-}
-
-func feedback(r *Routine) {
-	for event := range r.next() {
-		r.send(event)
-	}
-}
-
-func TestStatefulRoutine(t *testing.T) {
-	var (
-		count      = 10
-		handler    = genStatefulHandler(count)
-		bufferSize = 20
-		routine    = newRoutine("statefulRoutine", handler, bufferSize)
-	)
-
-	go routine.start()
-	go feedback(routine)
-	<-routine.ready()
-
-	assert.True(t, routine.send(eventA{}),
-		"expected sending to a started routine to succeed")
-
-	final := <-routine.final()
-	if fnl, ok := final.(finalCount); ok {
-		assert.Equal(t, count, fnl.count,
-			"expected the routine to count to 10")
-	} else {
-		t.Fail()
-	}
-}
-
-type lowPriorityEvent struct {
-	priorityLow
-}
-
-type highPriorityEvent struct {
-	priorityHigh
-}
-
-func handleWithPriority(event Event) (Event, error) {
-	switch event.(type) {
-	case lowPriorityEvent:
-		return noOp, nil
-	case highPriorityEvent:
-		return noOp, errDone
-	}
-	return noOp, nil
-}
-
-func TestPriority(t *testing.T) {
-	var (
-		bufferSize = 20
-		routine    = newRoutine("priorityRoutine", handleWithPriority, bufferSize)
-	)
-
-	go routine.start()
-	<-routine.ready()
-	go func() {
-		for {
-			routine.send(lowPriorityEvent{})
-			time.Sleep(1 * time.Millisecond)
-		}
-	}()
-	time.Sleep(10 * time.Millisecond)
-
-	assert.True(t, routine.isRunning(),
-		"expected an started routine")
-	assert.True(t, routine.send(highPriorityEvent{}),
-		"expected send to succeed even when saturated")
-
-	assert.Equal(t, errDone, <-routine.final())
-	assert.False(t, routine.isRunning(),
-		"expected an started routine")
-}
diff --git a/internal/blocksync/v2/scheduler.go b/internal/blocksync/v2/scheduler.go
deleted file mode 100644
index b731d96a4d..0000000000
--- a/internal/blocksync/v2/scheduler.go
+++ /dev/null
@@ -1,711 +0,0 @@
-package v2
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"math"
-	"sort"
-	"time"
-
-	"github.com/tendermint/tendermint/types"
-)
-
-// Events generated by the scheduler:
-// all blocks have been processed
-type scFinishedEv struct {
-	priorityNormal
-	reason string
-}
-
-func (e scFinishedEv) String() string {
-	return fmt.Sprintf("scFinishedEv{%v}", e.reason)
-}
-
-// send a blockRequest message
-type scBlockRequest struct {
-	priorityNormal
-	peerID types.NodeID
-	height int64
-}
-
-func (e scBlockRequest) String() string {
-	return fmt.Sprintf("scBlockRequest{%d from %v}", e.height, e.peerID)
-}
-
-// a block has been received and validated by the scheduler
-type scBlockReceived struct {
-	priorityNormal
-	peerID types.NodeID
-	block  *types.Block
-}
-
-func (e scBlockReceived) String() string {
-	return fmt.Sprintf("scBlockReceived{%d#%X from %v}", e.block.Height, e.block.Hash(), e.peerID)
-}
-
-// scheduler detected a peer error
-type scPeerError struct {
-	priorityHigh
-	peerID types.NodeID
-	reason error
-}
-
-func (e scPeerError) String() string {
-	return fmt.Sprintf("scPeerError{%v errored with %v}", e.peerID, e.reason)
-}
-
-// scheduler removed a set of peers (timed out or slow peer)
-type scPeersPruned struct {
-	priorityHigh
-	peers []types.NodeID
-}
-
-func (e scPeersPruned) String() string {
-	return fmt.Sprintf("scPeersPruned{%v}", e.peers)
-}
-
-// XXX: make this fatal?
-// scheduler encountered a fatal error
-type scSchedulerFail struct {
-	priorityHigh
-	reason error
-}
-
-func (e scSchedulerFail) String() string {
-	return fmt.Sprintf("scSchedulerFail{%v}", e.reason)
-}
-
-type blockState int
-
-const (
-	blockStateUnknown   blockState = iota + 1 // no known peer has this block
-	blockStateNew                             // indicates that a peer has reported having this block
-	blockStatePending                         // indicates that this block has been requested from a peer
-	blockStateReceived                        // indicates that this block has been received by a peer
-	blockStateProcessed                       // indicates that this block has been applied
-)
-
-func (e blockState) String() string {
-	switch e {
-	case blockStateUnknown:
-		return "Unknown"
-	case blockStateNew:
-		return "New"
-	case blockStatePending:
-		return "Pending"
-	case blockStateReceived:
-		return "Received"
-	case blockStateProcessed:
-		return "Processed"
-	default:
-		return fmt.Sprintf("invalid blockState: %d", e)
-	}
-}
-
-type peerState int
-
-const (
-	peerStateNew = iota + 1
-	peerStateReady
-	peerStateRemoved
-)
-
-func (e peerState) String() string {
-	switch e {
-	case peerStateNew:
-		return "New"
-	case peerStateReady:
-		return "Ready"
-	case peerStateRemoved:
-		return "Removed"
-	default:
-		panic(fmt.Sprintf("unknown peerState: %d", e))
-	}
-}
-
-type scPeer struct {
-	peerID types.NodeID
-
-	// initialized as New when peer is added, updated to Ready when statusUpdate is received,
-	// updated to Removed when peer is removed
-	state peerState
-
-	base        int64 // updated when statusResponse is received
-	height      int64 // updated when statusResponse is received
-	lastTouched time.Time
-	lastRate    int64 // last receive rate in bytes
-}
-
-func (p scPeer) String() string {
-	return fmt.Sprintf("{state %v, base %d, height %d, lastTouched %v, lastRate %d, id %v}",
-		p.state, p.base, p.height, p.lastTouched, p.lastRate, p.peerID)
-}
-
-func newScPeer(peerID types.NodeID) *scPeer {
-	return &scPeer{
-		peerID:      peerID,
-		state:       peerStateNew,
-		base:        -1,
-		height:      -1,
-		lastTouched: time.Time{},
-	}
-}
-
-// The scheduler keep track of the state of each block and each peer. The
-// scheduler will attempt to schedule new block requests with `trySchedule`
-// events and remove slow peers with `tryPrune` events.
-type scheduler struct {
-	initHeight int64
-
-	// next block that needs to be processed. All blocks with smaller height are
-	// in Processed state.
-	height int64
-
-	// lastAdvance tracks the last time a block execution happened.
-	// syncTimeout is the maximum time the scheduler waits to advance in the block sync process before finishing.
-	// This covers the cases where there are no peers or all peers have a lower height.
-	lastAdvance time.Time
-	syncTimeout time.Duration
-
-	// a map of peerID to scheduler specific peer struct `scPeer` used to keep
-	// track of peer specific state
-	peers       map[types.NodeID]*scPeer
-	peerTimeout time.Duration // maximum response time from a peer otherwise prune
-	minRecvRate int64         // minimum receive rate from peer otherwise prune
-
-	// the maximum number of blocks that should be New, Received or Pending at any point
-	// in time. This is used to enforce a limit on the blockStates map.
-	targetPending int
-	// a list of blocks to be scheduled (New), Pending or Received. Its length should be
-	// smaller than targetPending.
-	blockStates map[int64]blockState
-
-	// a map of heights to the peer we are waiting a response from
-	pendingBlocks map[int64]types.NodeID
-
-	// the time at which a block was put in blockStatePending
-	pendingTime map[int64]time.Time
-
-	// a map of heights to the peers that put the block in blockStateReceived
-	receivedBlocks map[int64]types.NodeID
-}
-
-func (sc scheduler) String() string {
-	return fmt.Sprintf("ih: %d, bst: %v, peers: %v, pblks: %v, ptm %v, rblks: %v",
-		sc.initHeight, sc.blockStates, sc.peers, sc.pendingBlocks, sc.pendingTime, sc.receivedBlocks)
-}
-
-func newScheduler(initHeight int64, startTime time.Time) *scheduler {
-	sc := scheduler{
-		initHeight:     initHeight,
-		lastAdvance:    startTime,
-		syncTimeout:    60 * time.Second,
-		height:         initHeight,
-		blockStates:    make(map[int64]blockState),
-		peers:          make(map[types.NodeID]*scPeer),
-		pendingBlocks:  make(map[int64]types.NodeID),
-		pendingTime:    make(map[int64]time.Time),
-		receivedBlocks: make(map[int64]types.NodeID),
-		targetPending:  10,               // TODO - pass as param
-		peerTimeout:    15 * time.Second, // TODO - pass as param
-		minRecvRate:    0,                // int64(7680), TODO - pass as param
-	}
-
-	return &sc
-}
-
-func (sc *scheduler) ensurePeer(peerID types.NodeID) *scPeer {
-	if _, ok := sc.peers[peerID]; !ok {
-		sc.peers[peerID] = newScPeer(peerID)
-	}
-	return sc.peers[peerID]
-}
-
-func (sc *scheduler) touchPeer(peerID types.NodeID, time time.Time) error {
-	peer, ok := sc.peers[peerID]
-	if !ok {
-		return fmt.Errorf("couldn't find peer %s", peerID)
-	}
-
-	if peer.state != peerStateReady {
-		return fmt.Errorf("tried to touch peer in state %s, must be Ready", peer.state)
-	}
-
-	peer.lastTouched = time
-
-	return nil
-}
-
-func (sc *scheduler) removePeer(peerID types.NodeID) {
-	peer, ok := sc.peers[peerID]
-	if !ok {
-		return
-	}
-	if peer.state == peerStateRemoved {
-		return
-	}
-
-	for height, pendingPeerID := range sc.pendingBlocks {
-		if pendingPeerID == peerID {
-			sc.setStateAtHeight(height, blockStateNew)
-			delete(sc.pendingTime, height)
-			delete(sc.pendingBlocks, height)
-		}
-	}
-
-	for height, rcvPeerID := range sc.receivedBlocks {
-		if rcvPeerID == peerID {
-			sc.setStateAtHeight(height, blockStateNew)
-			delete(sc.receivedBlocks, height)
-		}
-	}
-
-	// remove the blocks from blockStates if the peer removal causes the max peer height to be lower.
-	peer.state = peerStateRemoved
-	maxPeerHeight := int64(0)
-	for _, otherPeer := range sc.peers {
-		if otherPeer.state != peerStateReady {
-			continue
-		}
-		if otherPeer.peerID != peer.peerID && otherPeer.height > maxPeerHeight {
-			maxPeerHeight = otherPeer.height
-		}
-	}
-	for h := range sc.blockStates {
-		if h > maxPeerHeight {
-			delete(sc.blockStates, h)
-		}
-	}
-}
-
-// check if the blockPool is running low and add new blocks in New state to be requested.
-// This function is called when there is an increase in the maximum peer height or when
-// blocks are processed.
-func (sc *scheduler) addNewBlocks() {
-	if len(sc.blockStates) >= sc.targetPending {
-		return
-	}
-
-	for i := sc.height; i < int64(sc.targetPending)+sc.height; i++ {
-		if i > sc.maxHeight() {
-			break
-		}
-		if sc.getStateAtHeight(i) == blockStateUnknown {
-			sc.setStateAtHeight(i, blockStateNew)
-		}
-	}
-}
-
-func (sc *scheduler) setPeerRange(peerID types.NodeID, base int64, height int64) error {
-	peer := sc.ensurePeer(peerID)
-
-	if peer.state == peerStateRemoved {
-		return nil // noop
-	}
-
-	if height < peer.height {
-		sc.removePeer(peerID)
-		return fmt.Errorf("cannot move peer height lower. from %d to %d", peer.height, height)
-	}
-
-	if base > height {
-		sc.removePeer(peerID)
-		return fmt.Errorf("cannot set peer base higher than its height")
-	}
-
-	peer.base = base
-	peer.height = height
-	peer.state = peerStateReady
-
-	sc.addNewBlocks()
-	return nil
-}
-
-func (sc *scheduler) getStateAtHeight(height int64) blockState {
-	if height < sc.height {
-		return blockStateProcessed
-	} else if state, ok := sc.blockStates[height]; ok {
-		return state
-	} else {
-		return blockStateUnknown
-	}
-}
-
-func (sc *scheduler) getPeersWithHeight(height int64) []types.NodeID {
-	peers := make([]types.NodeID, 0)
-	for _, peer := range sc.peers {
-		if peer.state != peerStateReady {
-			continue
-		}
-		if peer.base <= height && peer.height >= height {
-			peers = append(peers, peer.peerID)
-		}
-	}
-	return peers
-}
-
-func (sc *scheduler) prunablePeers(peerTimout time.Duration, minRecvRate int64, now time.Time) []types.NodeID {
-	prunable := make([]types.NodeID, 0)
-	for peerID, peer := range sc.peers {
-		if peer.state != peerStateReady {
-			continue
-		}
-		if now.Sub(peer.lastTouched) > peerTimout || peer.lastRate < minRecvRate {
-			prunable = append(prunable, peerID)
-		}
-	}
-	// Tests for handleTryPrunePeer() may fail without sort due to range non-determinism
-	sort.Sort(PeerByID(prunable))
-	return prunable
-}
-
-func (sc *scheduler) setStateAtHeight(height int64, state blockState) {
-	sc.blockStates[height] = state
-}
-
-// CONTRACT: peer exists and in Ready state.
-func (sc *scheduler) markReceived(peerID types.NodeID, height int64, size int64, now time.Time) error {
-	peer := sc.peers[peerID]
-
-	if state := sc.getStateAtHeight(height); state != blockStatePending || sc.pendingBlocks[height] != peerID {
-		return fmt.Errorf("received block %d from peer %s without being requested", height, peerID)
-	}
-
-	pendingTime, ok := sc.pendingTime[height]
-	if !ok || now.Sub(pendingTime) <= 0 {
-		return fmt.Errorf("clock error: block %d received at %s but requested at %s",
-			height, pendingTime, now)
-	}
-
-	peer.lastRate = size / now.Sub(pendingTime).Nanoseconds()
-
-	sc.setStateAtHeight(height, blockStateReceived)
-	delete(sc.pendingBlocks, height)
-	delete(sc.pendingTime, height)
-
-	sc.receivedBlocks[height] = peerID
-
-	return nil
-}
-
-func (sc *scheduler) markPending(peerID types.NodeID, height int64, time time.Time) error {
-	state := sc.getStateAtHeight(height)
-	if state != blockStateNew {
-		return fmt.Errorf("block %d should be in blockStateNew but is %s", height, state)
-	}
-
-	peer, ok := sc.peers[peerID]
-	if !ok {
-		return fmt.Errorf("cannot find peer %s", peerID)
-	}
-
-	if peer.state != peerStateReady {
-		return fmt.Errorf("cannot schedule %d from %s in %s", height, peerID, peer.state)
-	}
-
-	if height > peer.height {
-		return fmt.Errorf("cannot request height %d from peer %s that is at height %d",
-			height, peerID, peer.height)
-	}
-
-	if height < peer.base {
-		return fmt.Errorf("cannot request height %d for peer %s with base %d",
-			height, peerID, peer.base)
-	}
-
-	sc.setStateAtHeight(height, blockStatePending)
-	sc.pendingBlocks[height] = peerID
-	sc.pendingTime[height] = time
-
-	return nil
-}
-
-func (sc *scheduler) markProcessed(height int64) error {
-	// It is possible that a peer error or timeout is handled after the processor
-	// has processed the block but before the scheduler received this event, so
-	// when pcBlockProcessed event is received, the block had been requested
-	// again => don't check the block state.
-	sc.lastAdvance = time.Now()
-	sc.height = height + 1
-	delete(sc.pendingBlocks, height)
-	delete(sc.pendingTime, height)
-	delete(sc.receivedBlocks, height)
-	delete(sc.blockStates, height)
-	sc.addNewBlocks()
-	return nil
-}
-
-func (sc *scheduler) allBlocksProcessed() bool {
-	if len(sc.peers) == 0 {
-		return false
-	}
-	return sc.height >= sc.maxHeight()
-}
-
-// returns max peer height or the last processed block, i.e. sc.height
-func (sc *scheduler) maxHeight() int64 {
-	max := sc.height - 1
-	for _, peer := range sc.peers {
-		if peer.state != peerStateReady {
-			continue
-		}
-		if max < peer.height {
-			max = peer.height
-		}
-	}
-	return max
-}
-
-// lowest block in sc.blockStates with state == blockStateNew or -1 if no new blocks
-func (sc *scheduler) nextHeightToSchedule() int64 {
-	var min int64 = math.MaxInt64
-	for height, state := range sc.blockStates {
-		if state == blockStateNew && height < min {
-			min = height
-		}
-	}
-	if min == math.MaxInt64 {
-		min = -1
-	}
-	return min
-}
-
-func (sc *scheduler) pendingFrom(peerID types.NodeID) []int64 {
-	var heights []int64
-	for height, pendingPeerID := range sc.pendingBlocks {
-		if pendingPeerID == peerID {
-			heights = append(heights, height)
-		}
-	}
-	return heights
-}
-
-func (sc *scheduler) selectPeer(height int64) (types.NodeID, error) {
-	peers := sc.getPeersWithHeight(height)
-	if len(peers) == 0 {
-		return "", fmt.Errorf("cannot find peer for height %d", height)
-	}
-
-	// create a map from number of pending requests to a list
-	// of peers having that number of pending requests.
-	pendingFrom := make(map[int][]types.NodeID)
-	for _, peerID := range peers {
-		numPending := len(sc.pendingFrom(peerID))
-		pendingFrom[numPending] = append(pendingFrom[numPending], peerID)
-	}
-
-	// find the set of peers with minimum number of pending requests.
-	var minPending int64 = math.MaxInt64
-	for mp := range pendingFrom {
-		if int64(mp) < minPending {
-			minPending = int64(mp)
-		}
-	}
-
-	sort.Sort(PeerByID(pendingFrom[int(minPending)]))
-	return pendingFrom[int(minPending)][0], nil
-}
-
-// PeerByID is a list of peers sorted by peerID.
-type PeerByID []types.NodeID
-
-func (peers PeerByID) Len() int {
-	return len(peers)
-}
-func (peers PeerByID) Less(i, j int) bool {
-	return bytes.Compare([]byte(peers[i]), []byte(peers[j])) == -1
-}
-
-func (peers PeerByID) Swap(i, j int) {
-	peers[i], peers[j] = peers[j], peers[i]
-}
-
-// Handlers
-
-// This handler gets the block, performs some validation and then passes it on to the processor.
-func (sc *scheduler) handleBlockResponse(event bcBlockResponse) (Event, error) {
-	err := sc.touchPeer(event.peerID, event.time)
-	if err != nil {
-		// peer does not exist OR not ready
-		return noOp, nil
-	}
-
-	err = sc.markReceived(event.peerID, event.block.Height, event.size, event.time)
-	if err != nil {
-		sc.removePeer(event.peerID)
-		return scPeerError{peerID: event.peerID, reason: err}, nil
-	}
-
-	return scBlockReceived{peerID: event.peerID, block: event.block}, nil
-}
-
-func (sc *scheduler) handleNoBlockResponse(event bcNoBlockResponse) (Event, error) {
-	// No such peer or peer was removed.
-	peer, ok := sc.peers[event.peerID]
-	if !ok || peer.state == peerStateRemoved {
-		return noOp, nil
-	}
-
-	// The peer may have been just removed due to errors, low speed or timeouts.
-	sc.removePeer(event.peerID)
-
-	return scPeerError{peerID: event.peerID,
-		reason: fmt.Errorf("peer %v with base %d height %d claims no block for %d",
-			event.peerID, peer.base, peer.height, event.height)}, nil
-}
-
-func (sc *scheduler) handleBlockProcessed(event pcBlockProcessed) (Event, error) {
-	if event.height != sc.height {
-		panic(fmt.Sprintf("processed height %d, but expected height %d", event.height, sc.height))
-	}
-
-	err := sc.markProcessed(event.height)
-	if err != nil {
-		return scSchedulerFail{reason: err}, nil
-	}
-
-	if sc.allBlocksProcessed() {
-		return scFinishedEv{reason: "processed all blocks"}, nil
-	}
-
-	return noOp, nil
-}
-
-// Handles an error from the processor. The processor had already cleaned the blocks from
-// the peers included in this event. Just attempt to remove the peers.
-func (sc *scheduler) handleBlockProcessError(event pcBlockVerificationFailure) (Event, error) {
-	// The peers may have been just removed due to errors, low speed or timeouts.
-	sc.removePeer(event.firstPeerID)
-	if event.firstPeerID != event.secondPeerID {
-		sc.removePeer(event.secondPeerID)
-	}
-
-	if sc.allBlocksProcessed() {
-		return scFinishedEv{reason: "error on last block"}, nil
-	}
-
-	return noOp, nil
-}
-
-func (sc *scheduler) handleAddNewPeer(event bcAddNewPeer) (Event, error) {
-	sc.ensurePeer(event.peerID)
-	return noOp, nil
-}
-
-func (sc *scheduler) handleRemovePeer(event bcRemovePeer) (Event, error) {
-	sc.removePeer(event.peerID)
-
-	if sc.allBlocksProcessed() {
-		return scFinishedEv{reason: "removed peer"}, nil
-	}
-
-	// Return scPeerError so the peer (and all associated blocks) is removed from
-	// the processor.
-	return scPeerError{peerID: event.peerID, reason: errors.New("peer was stopped")}, nil
-}
-
-func (sc *scheduler) handleTryPrunePeer(event rTryPrunePeer) (Event, error) {
-	// Check behavior of peer responsible to deliver block at sc.height.
-	timeHeightAsked, ok := sc.pendingTime[sc.height]
-	if ok && time.Since(timeHeightAsked) > sc.peerTimeout {
-		// A request was sent to a peer for block at sc.height but a response was not received
-		// from that peer within sc.peerTimeout. Remove the peer. This is to ensure that a peer
-		// will be timed out even if it sends blocks at higher heights but prevents progress by
-		// not sending the block at current height.
-		sc.removePeer(sc.pendingBlocks[sc.height])
-	}
-
-	prunablePeers := sc.prunablePeers(sc.peerTimeout, sc.minRecvRate, event.time)
-	if len(prunablePeers) == 0 {
-		return noOp, nil
-	}
-	for _, peerID := range prunablePeers {
-		sc.removePeer(peerID)
-	}
-
-	// If all blocks are processed we should finish.
-	if sc.allBlocksProcessed() {
-		return scFinishedEv{reason: "after try prune"}, nil
-	}
-
-	return scPeersPruned{peers: prunablePeers}, nil
-}
-
-func (sc *scheduler) handleResetState(event bcResetState) (Event, error) {
-	initHeight := event.state.LastBlockHeight + 1
-	if initHeight == 1 {
-		initHeight = event.state.InitialHeight
-	}
-	sc.initHeight = initHeight
-	sc.height = initHeight
-	sc.lastAdvance = time.Now()
-	sc.addNewBlocks()
-	return noOp, nil
-}
-
-func (sc *scheduler) handleTrySchedule(event rTrySchedule) (Event, error) {
-	if time.Since(sc.lastAdvance) > sc.syncTimeout {
-		return scFinishedEv{reason: "timeout, no advance"}, nil
-	}
-
-	nextHeight := sc.nextHeightToSchedule()
-	if nextHeight == -1 {
-		return noOp, nil
-	}
-
-	bestPeerID, err := sc.selectPeer(nextHeight)
-	if err != nil {
-		return scSchedulerFail{reason: err}, nil
-	}
-	if err := sc.markPending(bestPeerID, nextHeight, event.time); err != nil {
-		return scSchedulerFail{reason: err}, nil // XXX: peerError might be more appropriate
-	}
-	return scBlockRequest{peerID: bestPeerID, height: nextHeight}, nil
-
-}
-
-func (sc *scheduler) handleStatusResponse(event bcStatusResponse) (Event, error) {
-	err := sc.setPeerRange(event.peerID, event.base, event.height)
-	if err != nil {
-		return scPeerError{peerID: event.peerID, reason: err}, nil
-	}
-	return noOp, nil
-}
-
-func (sc *scheduler) handle(event Event) (Event, error) {
-	switch event := event.(type) {
-	case bcResetState:
-		nextEvent, err := sc.handleResetState(event)
-		return nextEvent, err
-	case bcStatusResponse:
-		nextEvent, err := sc.handleStatusResponse(event)
-		return nextEvent, err
-	case bcBlockResponse:
-		nextEvent, err := sc.handleBlockResponse(event)
-		return nextEvent, err
-	case bcNoBlockResponse:
-		nextEvent, err := sc.handleNoBlockResponse(event)
-		return nextEvent, err
-	case rTrySchedule:
-		nextEvent, err := sc.handleTrySchedule(event)
-		return nextEvent, err
-	case bcAddNewPeer:
-		nextEvent, err := sc.handleAddNewPeer(event)
-		return nextEvent, err
-	case bcRemovePeer:
-		nextEvent, err := sc.handleRemovePeer(event)
-		return nextEvent, err
-	case rTryPrunePeer:
-		nextEvent, err := sc.handleTryPrunePeer(event)
-		return nextEvent, err
-	case pcBlockProcessed:
-		nextEvent, err := sc.handleBlockProcessed(event)
-		return nextEvent, err
-	case pcBlockVerificationFailure:
-		nextEvent, err := sc.handleBlockProcessError(event)
-		return nextEvent, err
-	default:
-		return scSchedulerFail{reason: fmt.Errorf("unknown event %v", event)}, nil
-	}
-}
diff --git a/internal/blocksync/v2/scheduler_test.go b/internal/blocksync/v2/scheduler_test.go
deleted file mode 100644
index d2c4aab03c..0000000000
--- a/internal/blocksync/v2/scheduler_test.go
+++ /dev/null
@@ -1,2253 +0,0 @@
-package v2
-
-import (
-	"fmt"
-	"math"
-	"sort"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/internal/state"
-	"github.com/tendermint/tendermint/types"
-)
-
-type scTestParams struct {
-	peers         map[string]*scPeer
-	initHeight    int64
-	height        int64
-	allB          []int64
-	pending       map[int64]types.NodeID
-	pendingTime   map[int64]time.Time
-	received      map[int64]types.NodeID
-	peerTimeout   time.Duration
-	minRecvRate   int64
-	targetPending int
-	startTime     time.Time
-	syncTimeout   time.Duration
-}
-
-func verifyScheduler(sc *scheduler) {
-	missing := 0
-	if sc.maxHeight() >= sc.height {
-		missing = int(math.Min(float64(sc.targetPending), float64(sc.maxHeight()-sc.height+1)))
-	}
-	if len(sc.blockStates) != missing {
-		panic(fmt.Sprintf("scheduler block length %d different than target %d", len(sc.blockStates), missing))
-	}
-}
-
-func newTestScheduler(params scTestParams) *scheduler {
-	peers := make(map[types.NodeID]*scPeer)
-	var maxHeight int64
-
-	initHeight := params.initHeight
-	if initHeight == 0 {
-		initHeight = 1
-	}
-	sc := newScheduler(initHeight, params.startTime)
-	if params.height != 0 {
-		sc.height = params.height
-	}
-
-	for id, peer := range params.peers {
-		peer.peerID = types.NodeID(id)
-		peers[types.NodeID(id)] = peer
-		if maxHeight < peer.height {
-			maxHeight = peer.height
-		}
-	}
-	for _, h := range params.allB {
-		sc.blockStates[h] = blockStateNew
-	}
-	for h, pid := range params.pending {
-		sc.blockStates[h] = blockStatePending
-		sc.pendingBlocks[h] = pid
-	}
-	for h, tm := range params.pendingTime {
-		sc.pendingTime[h] = tm
-	}
-	for h, pid := range params.received {
-		sc.blockStates[h] = blockStateReceived
-		sc.receivedBlocks[h] = pid
-	}
-
-	sc.peers = peers
-	sc.peerTimeout = params.peerTimeout
-	if params.syncTimeout == 0 {
-		sc.syncTimeout = 10 * time.Second
-	} else {
-		sc.syncTimeout = params.syncTimeout
-	}
-
-	if params.targetPending == 0 {
-		sc.targetPending = 10
-	} else {
-		sc.targetPending = params.targetPending
-	}
-
-	sc.minRecvRate = params.minRecvRate
-
-	verifyScheduler(sc)
-
-	return sc
-}
-
-func TestScInit(t *testing.T) {
-	var (
-		initHeight int64 = 5
-		sc               = newScheduler(initHeight, time.Now())
-	)
-	assert.Equal(t, blockStateProcessed, sc.getStateAtHeight(initHeight-1))
-	assert.Equal(t, blockStateUnknown, sc.getStateAtHeight(initHeight))
-	assert.Equal(t, blockStateUnknown, sc.getStateAtHeight(initHeight+1))
-}
-
-func TestScMaxHeights(t *testing.T) {
-
-	tests := []struct {
-		name    string
-		sc      scheduler
-		wantMax int64
-	}{
-		{
-			name:    "no peers",
-			sc:      scheduler{height: 11},
-			wantMax: 10,
-		},
-		{
-			name: "one ready peer",
-			sc: scheduler{
-				height: 3,
-				peers:  map[types.NodeID]*scPeer{"P1": {height: 6, state: peerStateReady}},
-			},
-			wantMax: 6,
-		},
-		{
-			name: "ready and removed peers",
-			sc: scheduler{
-				height: 1,
-				peers: map[types.NodeID]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 10, state: peerStateRemoved}},
-			},
-			wantMax: 4,
-		},
-		{
-			name: "removed peers",
-			sc: scheduler{
-				height: 1,
-				peers: map[types.NodeID]*scPeer{
-					"P1": {height: 4, state: peerStateRemoved},
-					"P2": {height: 10, state: peerStateRemoved}},
-			},
-			wantMax: 0,
-		},
-		{
-			name: "new peers",
-			sc: scheduler{
-				height: 1,
-				peers: map[types.NodeID]*scPeer{
-					"P1": {base: -1, height: -1, state: peerStateNew},
-					"P2": {base: -1, height: -1, state: peerStateNew}},
-			},
-			wantMax: 0,
-		},
-		{
-			name: "mixed peers",
-			sc: scheduler{
-				height: 1,
-				peers: map[types.NodeID]*scPeer{
-					"P1": {height: -1, state: peerStateNew},
-					"P2": {height: 10, state: peerStateReady},
-					"P3": {height: 20, state: peerStateRemoved},
-					"P4": {height: 22, state: peerStateReady},
-				},
-			},
-			wantMax: 22,
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			// maxHeight() should not mutate the scheduler
-			wantSc := tt.sc
-
-			resMax := tt.sc.maxHeight()
-			assert.Equal(t, tt.wantMax, resMax)
-			assert.Equal(t, wantSc, tt.sc)
-		})
-	}
-}
-
-func TestScEnsurePeer(t *testing.T) {
-
-	type args struct {
-		peerID types.NodeID
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantFields scTestParams
-	}{
-		{
-			name:       "add first peer",
-			fields:     scTestParams{},
-			args:       args{peerID: "P1"},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {base: -1, height: -1, state: peerStateNew}}},
-		},
-		{
-			name:   "add second peer",
-			fields: scTestParams{peers: map[string]*scPeer{"P1": {base: -1, height: -1, state: peerStateNew}}},
-			args:   args{peerID: "P2"},
-			wantFields: scTestParams{peers: map[string]*scPeer{
-				"P1": {base: -1, height: -1, state: peerStateNew},
-				"P2": {base: -1, height: -1, state: peerStateNew}}},
-		},
-		{
-			name:       "add duplicate peer is fine",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
-			args:       args{peerID: "P1"},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
-		},
-		{
-			name: "add duplicate peer with existing peer in Ready state is noop",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 3}},
-				allB:  []int64{1, 2, 3},
-			},
-			args: args{peerID: "P1"},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 3}},
-				allB:  []int64{1, 2, 3},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			sc.ensurePeer(tt.args.peerID)
-			wantSc := newTestScheduler(tt.wantFields)
-			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
-		})
-	}
-}
-
-func TestScTouchPeer(t *testing.T) {
-	now := time.Now()
-
-	type args struct {
-		peerID types.NodeID
-		time   time.Time
-	}
-
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantFields scTestParams
-		wantErr    bool
-	}{
-		{
-			name: "attempt to touch non existing peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 5}},
-				allB:  []int64{1, 2, 3, 4, 5},
-			},
-			args: args{peerID: "P2", time: now},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateReady, height: 5}},
-				allB: []int64{1, 2, 3, 4, 5},
-			},
-			wantErr: true,
-		},
-		{
-			name:       "attempt to touch peer in state New",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {}}},
-			args:       args{peerID: "P1", time: now},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {}}},
-			wantErr:    true,
-		},
-		{
-			name:       "attempt to touch peer in state Removed",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateRemoved}, "P2": {state: peerStateReady}}},
-			args:       args{peerID: "P1", time: now},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateRemoved}, "P2": {state: peerStateReady}}},
-			wantErr:    true,
-		},
-		{
-			name:   "touch peer in state Ready",
-			fields: scTestParams{peers: map[string]*scPeer{"P1": {state: peerStateReady, lastTouched: now}}},
-			args:   args{peerID: "P1", time: now.Add(3 * time.Second)},
-			wantFields: scTestParams{peers: map[string]*scPeer{
-				"P1": {state: peerStateReady, lastTouched: now.Add(3 * time.Second)}}},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			if err := sc.touchPeer(tt.args.peerID, tt.args.time); (err != nil) != tt.wantErr {
-				t.Errorf("touchPeer() wantErr %v, error = %v", tt.wantErr, err)
-			}
-			wantSc := newTestScheduler(tt.wantFields)
-			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
-		})
-	}
-}
-
-func TestScPrunablePeers(t *testing.T) {
-	now := time.Now()
-
-	type args struct {
-		threshold time.Duration
-		time      time.Time
-		minSpeed  int64
-	}
-
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantResult []types.NodeID
-	}{
-		{
-			name:       "no peers",
-			fields:     scTestParams{peers: map[string]*scPeer{}},
-			args:       args{threshold: time.Second, time: now.Add(time.Second + time.Millisecond), minSpeed: 100},
-			wantResult: []types.NodeID{},
-		},
-		{
-			name: "mixed peers",
-			fields: scTestParams{peers: map[string]*scPeer{
-				// X - removed, active, fast
-				"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101},
-				// X - ready, active, fast
-				"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101},
-				// X - removed, active, equal
-				"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100},
-				// V - ready, inactive, equal
-				"P4": {state: peerStateReady, lastTouched: now, lastRate: 100},
-				// V - ready, inactive, slow
-				"P5": {state: peerStateReady, lastTouched: now, lastRate: 99},
-				//  V - ready, active, slow
-				"P6": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 90},
-			}},
-			args:       args{threshold: time.Second, time: now.Add(time.Second + time.Millisecond), minSpeed: 100},
-			wantResult: []types.NodeID{"P4", "P5", "P6"},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			// peersSlowerThan should not mutate the scheduler
-			wantSc := sc
-			res := sc.prunablePeers(tt.args.threshold, tt.args.minSpeed, tt.args.time)
-			assert.Equal(t, tt.wantResult, res)
-			assert.Equal(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScRemovePeer(t *testing.T) {
-
-	type args struct {
-		peerID types.NodeID
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantFields scTestParams
-		wantErr    bool
-	}{
-		{
-			name:       "remove non existing peer",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
-			args:       args{peerID: "P2"},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
-		},
-		{
-			name:       "remove single New peer",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}}},
-			args:       args{peerID: "P1"},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateRemoved}}},
-		},
-		{
-			name:       "remove one of two New peers",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1}, "P2": {height: -1}}},
-			args:       args{peerID: "P1"},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateRemoved}, "P2": {height: -1}}},
-		},
-		{
-			name: "remove one Ready peer, all peers removed",
-			fields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 10, state: peerStateRemoved},
-					"P2": {height: 5, state: peerStateReady}},
-				allB: []int64{1, 2, 3, 4, 5},
-			},
-			args: args{peerID: "P2"},
-			wantFields: scTestParams{peers: map[string]*scPeer{
-				"P1": {height: 10, state: peerStateRemoved},
-				"P2": {height: 5, state: peerStateRemoved}},
-			},
-		},
-		{
-			name: "attempt to remove already removed peer",
-			fields: scTestParams{
-				height: 8,
-				peers: map[string]*scPeer{
-					"P1": {height: 10, state: peerStateRemoved},
-					"P2": {height: 11, state: peerStateReady}},
-				allB: []int64{8, 9, 10, 11},
-			},
-			args: args{peerID: "P1"},
-			wantFields: scTestParams{
-				height: 8,
-				peers: map[string]*scPeer{
-					"P1": {height: 10, state: peerStateRemoved},
-					"P2": {height: 11, state: peerStateReady}},
-				allB: []int64{8, 9, 10, 11}},
-		},
-		{
-			name: "remove Ready peer with blocks requested",
-			fields: scTestParams{
-				peers:   map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
-				allB:    []int64{1, 2, 3},
-				pending: map[int64]types.NodeID{1: "P1"},
-			},
-			args: args{peerID: "P1"},
-			wantFields: scTestParams{
-				peers:   map[string]*scPeer{"P1": {height: 3, state: peerStateRemoved}},
-				allB:    []int64{},
-				pending: map[int64]types.NodeID{},
-			},
-		},
-		{
-			name: "remove Ready peer with blocks received",
-			fields: scTestParams{
-				peers:    map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
-				allB:     []int64{1, 2, 3},
-				received: map[int64]types.NodeID{1: "P1"},
-			},
-			args: args{peerID: "P1"},
-			wantFields: scTestParams{
-				peers:    map[string]*scPeer{"P1": {height: 3, state: peerStateRemoved}},
-				allB:     []int64{},
-				received: map[int64]types.NodeID{},
-			},
-		},
-		{
-			name: "remove Ready peer with blocks received and requested (not yet received)",
-			fields: scTestParams{
-				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:     []int64{1, 2, 3, 4},
-				pending:  map[int64]types.NodeID{1: "P1", 3: "P1"},
-				received: map[int64]types.NodeID{2: "P1", 4: "P1"},
-			},
-			args: args{peerID: "P1"},
-			wantFields: scTestParams{
-				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}},
-				allB:     []int64{},
-				pending:  map[int64]types.NodeID{},
-				received: map[int64]types.NodeID{},
-			},
-		},
-		{
-			name: "remove Ready peer from multiple peers set, with blocks received and requested (not yet received)",
-			fields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 6, state: peerStateReady},
-					"P2": {height: 6, state: peerStateReady},
-				},
-				allB:     []int64{1, 2, 3, 4, 5, 6},
-				pending:  map[int64]types.NodeID{1: "P1", 3: "P2", 6: "P1"},
-				received: map[int64]types.NodeID{2: "P1", 4: "P2", 5: "P2"},
-			},
-			args: args{peerID: "P1"},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 6, state: peerStateRemoved},
-					"P2": {height: 6, state: peerStateReady},
-				},
-				allB:     []int64{1, 2, 3, 4, 5, 6},
-				pending:  map[int64]types.NodeID{3: "P2"},
-				received: map[int64]types.NodeID{4: "P2", 5: "P2"},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			sc.removePeer(tt.args.peerID)
-			wantSc := newTestScheduler(tt.wantFields)
-			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
-		})
-	}
-}
-
-func TestScSetPeerRange(t *testing.T) {
-
-	type args struct {
-		peerID types.NodeID
-		base   int64
-		height int64
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantFields scTestParams
-		wantErr    bool
-	}{
-		{
-			name: "change height of non existing peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			args: args{peerID: "P2", height: 4},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 2, state: peerStateReady},
-					"P2": {height: 4, state: peerStateReady},
-				},
-				allB: []int64{1, 2, 3, 4}},
-		},
-		{
-			name: "increase height of removed peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
-			args:       args{peerID: "P1", height: 4},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
-		},
-		{
-			name: "decrease height of single peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4}},
-			args: args{peerID: "P1", height: 2},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}},
-				allB:  []int64{}},
-			wantErr: true,
-		},
-		{
-			name: "increase height of single peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			args: args{peerID: "P1", height: 4},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4}},
-		},
-		{
-			name: "noop height change of single peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4}},
-			args: args{peerID: "P1", height: 4},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4}},
-		},
-		{
-			name: "add peer with huge height 10**10 ",
-			fields: scTestParams{
-				peers:         map[string]*scPeer{"P2": {height: -1, state: peerStateNew}},
-				targetPending: 4,
-			},
-			args: args{peerID: "P2", height: 10000000000},
-			wantFields: scTestParams{
-				targetPending: 4,
-				peers:         map[string]*scPeer{"P2": {height: 10000000000, state: peerStateReady}},
-				allB:          []int64{1, 2, 3, 4}},
-		},
-		{
-			name: "add peer with base > height should error",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4}},
-			args: args{peerID: "P1", base: 6, height: 5},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
-			wantErr: true,
-		},
-		{
-			name: "add peer with base == height is fine",
-			fields: scTestParams{
-				peers:         map[string]*scPeer{"P1": {height: 4, state: peerStateNew}},
-				targetPending: 4,
-			},
-			args: args{peerID: "P1", base: 6, height: 6},
-			wantFields: scTestParams{
-				targetPending: 4,
-				peers:         map[string]*scPeer{"P1": {base: 6, height: 6, state: peerStateReady}},
-				allB:          []int64{1, 2, 3, 4}},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			err := sc.setPeerRange(tt.args.peerID, tt.args.base, tt.args.height)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("setPeerHeight() wantErr %v, error = %v", tt.wantErr, err)
-			}
-			wantSc := newTestScheduler(tt.wantFields)
-			assert.Equal(t, wantSc, sc, "wanted peers %v, got %v", wantSc.peers, sc.peers)
-		})
-	}
-}
-
-func TestScGetPeersWithHeight(t *testing.T) {
-
-	type args struct {
-		height int64
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantResult []types.NodeID
-	}{
-		{
-			name:       "no peers",
-			fields:     scTestParams{peers: map[string]*scPeer{}},
-			args:       args{height: 10},
-			wantResult: []types.NodeID{},
-		},
-		{
-			name:       "only new peers",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateNew}}},
-			args:       args{height: 10},
-			wantResult: []types.NodeID{},
-		},
-		{
-			name:       "only Removed peers",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
-			args:       args{height: 2},
-			wantResult: []types.NodeID{},
-		},
-		{
-			name: "one Ready shorter peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4},
-			},
-			args:       args{height: 5},
-			wantResult: []types.NodeID{},
-		},
-		{
-			name: "one Ready equal peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4},
-			},
-			args:       args{height: 4},
-			wantResult: []types.NodeID{"P1"},
-		},
-		{
-			name: "one Ready higher peer",
-			fields: scTestParams{
-				targetPending: 4,
-				peers:         map[string]*scPeer{"P1": {height: 20, state: peerStateReady}},
-				allB:          []int64{1, 2, 3, 4},
-			},
-			args:       args{height: 4},
-			wantResult: []types.NodeID{"P1"},
-		},
-		{
-			name: "one Ready higher peer at base",
-			fields: scTestParams{
-				targetPending: 4,
-				peers:         map[string]*scPeer{"P1": {base: 4, height: 20, state: peerStateReady}},
-				allB:          []int64{1, 2, 3, 4},
-			},
-			args:       args{height: 4},
-			wantResult: []types.NodeID{"P1"},
-		},
-		{
-			name: "one Ready higher peer with higher base",
-			fields: scTestParams{
-				targetPending: 4,
-				peers:         map[string]*scPeer{"P1": {base: 10, height: 20, state: peerStateReady}},
-				allB:          []int64{1, 2, 3, 4},
-			},
-			args:       args{height: 4},
-			wantResult: []types.NodeID{},
-		},
-		{
-			name: "multiple mixed peers",
-			fields: scTestParams{
-				height: 8,
-				peers: map[string]*scPeer{
-					"P1": {height: -1, state: peerStateNew},
-					"P2": {height: 10, state: peerStateReady},
-					"P3": {height: 5, state: peerStateReady},
-					"P4": {height: 20, state: peerStateRemoved},
-					"P5": {height: 11, state: peerStateReady}},
-				allB: []int64{8, 9, 10, 11},
-			},
-			args:       args{height: 8},
-			wantResult: []types.NodeID{"P2", "P5"},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			// getPeersWithHeight should not mutate the scheduler
-			wantSc := sc
-			res := sc.getPeersWithHeight(tt.args.height)
-			sort.Sort(PeerByID(res))
-			assert.Equal(t, tt.wantResult, res)
-			assert.Equal(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScMarkPending(t *testing.T) {
-	now := time.Now()
-
-	type args struct {
-		peerID types.NodeID
-		height int64
-		tm     time.Time
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantFields scTestParams
-		wantErr    bool
-	}{
-		{
-			name: "attempt mark pending an unknown block above height",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			args: args{peerID: "P1", height: 3, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			wantErr: true,
-		},
-		{
-			name: "attempt mark pending an unknown block below base",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {base: 4, height: 6, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4, 5, 6}},
-			args: args{peerID: "P1", height: 3, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {base: 4, height: 6, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4, 5, 6}},
-			wantErr: true,
-		},
-		{
-			name: "attempt mark pending from non existing peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			args: args{peerID: "P2", height: 1, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			wantErr: true,
-		},
-		{
-			name: "mark pending from Removed peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
-			args: args{peerID: "P1", height: 1, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
-			wantErr: true,
-		},
-		{
-			name: "mark pending from New peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 4, state: peerStateNew},
-				},
-				allB: []int64{1, 2, 3, 4},
-			},
-			args: args{peerID: "P2", height: 2, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 4, state: peerStateNew},
-				},
-				allB: []int64{1, 2, 3, 4},
-			},
-			wantErr: true,
-		},
-		{
-			name: "mark pending from short peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 2, state: peerStateReady},
-				},
-				allB: []int64{1, 2, 3, 4},
-			},
-			args: args{peerID: "P2", height: 3, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 2, state: peerStateReady},
-				},
-				allB: []int64{1, 2, 3, 4},
-			},
-			wantErr: true,
-		},
-		{
-			name: "mark pending all good",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{1, 2},
-				pending:     map[int64]types.NodeID{1: "P1"},
-				pendingTime: map[int64]time.Time{1: now},
-			},
-			args: args{peerID: "P1", height: 2, tm: now.Add(time.Millisecond)},
-			wantFields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{1, 2},
-				pending:     map[int64]types.NodeID{1: "P1", 2: "P1"},
-				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Millisecond)},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			if err := sc.markPending(tt.args.peerID, tt.args.height, tt.args.tm); (err != nil) != tt.wantErr {
-				t.Errorf("markPending() wantErr %v, error = %v", tt.wantErr, err)
-			}
-			wantSc := newTestScheduler(tt.wantFields)
-			assert.Equal(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScMarkReceived(t *testing.T) {
-	now := time.Now()
-
-	type args struct {
-		peerID types.NodeID
-		height int64
-		size   int64
-		tm     time.Time
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantFields scTestParams
-		wantErr    bool
-	}{
-		{
-			name: "received from non existing peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			args: args{peerID: "P2", height: 1, size: 1000, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			wantErr: true,
-		},
-		{
-			name: "received from removed peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
-			args: args{peerID: "P1", height: 1, size: 1000, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
-			wantErr: true,
-		},
-		{
-			name: "received from unsolicited peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 4, state: peerStateReady},
-				},
-				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]types.NodeID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
-			},
-			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
-			wantFields: scTestParams{
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 4, state: peerStateReady},
-				},
-				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]types.NodeID{1: "P1", 2: "P2", 3: "P2", 4: "P1"},
-			},
-			wantErr: true,
-		},
-		{
-			name: "received but blockRequest not sent",
-			fields: scTestParams{
-				peers:   map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]types.NodeID{},
-			},
-			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
-			wantFields: scTestParams{
-				peers:   map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:    []int64{1, 2, 3, 4},
-				pending: map[int64]types.NodeID{},
-			},
-			wantErr: true,
-		},
-		{
-			name: "received with bad timestamp",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{1, 2},
-				pending:     map[int64]types.NodeID{1: "P1", 2: "P1"},
-				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Second)},
-			},
-			args: args{peerID: "P1", height: 2, size: 1000, tm: now},
-			wantFields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{1, 2},
-				pending:     map[int64]types.NodeID{1: "P1", 2: "P1"},
-				pendingTime: map[int64]time.Time{1: now, 2: now.Add(time.Second)},
-			},
-			wantErr: true,
-		},
-		{
-			name: "received all good",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{1, 2},
-				pending:     map[int64]types.NodeID{1: "P1", 2: "P1"},
-				pendingTime: map[int64]time.Time{1: now, 2: now},
-			},
-			args: args{peerID: "P1", height: 2, size: 1000, tm: now.Add(time.Millisecond)},
-			wantFields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{1, 2},
-				pending:     map[int64]types.NodeID{1: "P1"},
-				pendingTime: map[int64]time.Time{1: now},
-				received:    map[int64]types.NodeID{2: "P1"},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			if err := sc.markReceived(
-				tt.args.peerID,
-				tt.args.height,
-				tt.args.size,
-				now.Add(time.Second)); (err != nil) != tt.wantErr {
-				t.Errorf("markReceived() wantErr %v, error = %v", tt.wantErr, err)
-			}
-			wantSc := newTestScheduler(tt.wantFields)
-			assert.Equal(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScMarkProcessed(t *testing.T) {
-	now := time.Now()
-
-	type args struct {
-		height int64
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantFields scTestParams
-		wantErr    bool
-	}{
-		{
-			name: "processed an unreceived block",
-			fields: scTestParams{
-				height:        2,
-				peers:         map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:          []int64{2},
-				pending:       map[int64]types.NodeID{2: "P1"},
-				pendingTime:   map[int64]time.Time{2: now},
-				targetPending: 1,
-			},
-			args: args{height: 2},
-			wantFields: scTestParams{
-				height:        3,
-				peers:         map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:          []int64{3},
-				targetPending: 1,
-			},
-		},
-		{
-			name: "mark processed success",
-			fields: scTestParams{
-				height:      1,
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{1, 2},
-				pending:     map[int64]types.NodeID{2: "P1"},
-				pendingTime: map[int64]time.Time{2: now},
-				received:    map[int64]types.NodeID{1: "P1"}},
-			args: args{height: 1},
-			wantFields: scTestParams{
-				height:      2,
-				peers:       map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:        []int64{2},
-				pending:     map[int64]types.NodeID{2: "P1"},
-				pendingTime: map[int64]time.Time{2: now}},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			oldBlockState := sc.getStateAtHeight(tt.args.height)
-			if err := sc.markProcessed(tt.args.height); (err != nil) != tt.wantErr {
-				t.Errorf("markProcessed() wantErr %v, error = %v", tt.wantErr, err)
-			}
-			if tt.wantErr {
-				assert.Equal(t, oldBlockState, sc.getStateAtHeight(tt.args.height))
-			} else {
-				assert.Equal(t, blockStateProcessed, sc.getStateAtHeight(tt.args.height))
-			}
-			wantSc := newTestScheduler(tt.wantFields)
-			checkSameScheduler(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScResetState(t *testing.T) {
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		state      state.State
-		wantFields scTestParams
-	}{
-		{
-			name: "updates height and initHeight",
-			fields: scTestParams{
-				height:     0,
-				initHeight: 0,
-			},
-			state: state.State{LastBlockHeight: 7},
-			wantFields: scTestParams{
-				height:     8,
-				initHeight: 8,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			e, err := sc.handleResetState(bcResetState{state: tt.state})
-			require.NoError(t, err)
-			assert.Equal(t, e, noOp)
-			wantSc := newTestScheduler(tt.wantFields)
-			checkSameScheduler(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScAllBlocksProcessed(t *testing.T) {
-	now := time.Now()
-
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		wantResult bool
-	}{
-		{
-			name:       "no blocks, no peers",
-			fields:     scTestParams{},
-			wantResult: false,
-		},
-		{
-			name: "only New blocks",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4},
-			},
-			wantResult: false,
-		},
-		{
-			name: "only Pending blocks",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]types.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
-				pendingTime: map[int64]time.Time{1: now, 2: now, 3: now, 4: now},
-			},
-			wantResult: false,
-		},
-		{
-			name: "only Received blocks",
-			fields: scTestParams{
-				peers:    map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:     []int64{1, 2, 3, 4},
-				received: map[int64]types.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
-			},
-			wantResult: false,
-		},
-		{
-			name: "only Processed blocks plus highest is received",
-			fields: scTestParams{
-				height: 4,
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady}},
-				allB:     []int64{4},
-				received: map[int64]types.NodeID{4: "P1"},
-			},
-			wantResult: true,
-		},
-		{
-			name: "mixed block states",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]types.NodeID{2: "P1", 4: "P1"},
-				pendingTime: map[int64]time.Time{2: now, 4: now},
-			},
-			wantResult: false,
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			// allBlocksProcessed() should not mutate the scheduler
-			wantSc := sc
-			res := sc.allBlocksProcessed()
-			assert.Equal(t, tt.wantResult, res)
-			checkSameScheduler(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScNextHeightToSchedule(t *testing.T) {
-	now := time.Now()
-
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		wantHeight int64
-	}{
-		{
-			name:       "no blocks",
-			fields:     scTestParams{initHeight: 11, height: 11},
-			wantHeight: -1,
-		},
-		{
-			name: "only New blocks",
-			fields: scTestParams{
-				initHeight: 3,
-				peers:      map[string]*scPeer{"P1": {height: 6, state: peerStateReady}},
-				allB:       []int64{3, 4, 5, 6},
-			},
-			wantHeight: 3,
-		},
-		{
-			name: "only Pending blocks",
-			fields: scTestParams{
-				initHeight:  1,
-				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]types.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
-				pendingTime: map[int64]time.Time{1: now, 2: now, 3: now, 4: now},
-			},
-			wantHeight: -1,
-		},
-		{
-			name: "only Received blocks",
-			fields: scTestParams{
-				initHeight: 1,
-				peers:      map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:       []int64{1, 2, 3, 4},
-				received:   map[int64]types.NodeID{1: "P1", 2: "P1", 3: "P1", 4: "P1"},
-			},
-			wantHeight: -1,
-		},
-		{
-			name: "only Processed blocks",
-			fields: scTestParams{
-				initHeight: 1,
-				peers:      map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:       []int64{1, 2, 3, 4},
-			},
-			wantHeight: 1,
-		},
-		{
-			name: "mixed block states",
-			fields: scTestParams{
-				initHeight:  1,
-				peers:       map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4},
-				pending:     map[int64]types.NodeID{2: "P1"},
-				pendingTime: map[int64]time.Time{2: now},
-			},
-			wantHeight: 1,
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			// nextHeightToSchedule() should not mutate the scheduler
-			wantSc := sc
-
-			resMin := sc.nextHeightToSchedule()
-			assert.Equal(t, tt.wantHeight, resMin)
-			checkSameScheduler(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScSelectPeer(t *testing.T) {
-
-	type args struct {
-		height int64
-	}
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		args       args
-		wantResult types.NodeID
-		wantError  bool
-	}{
-		{
-			name:       "no peers",
-			fields:     scTestParams{peers: map[string]*scPeer{}},
-			args:       args{height: 10},
-			wantResult: "",
-			wantError:  true,
-		},
-		{
-			name:       "only new peers",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: -1, state: peerStateNew}}},
-			args:       args{height: 10},
-			wantResult: "",
-			wantError:  true,
-		},
-		{
-			name:       "only Removed peers",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
-			args:       args{height: 2},
-			wantResult: "",
-			wantError:  true,
-		},
-		{
-			name: "one Ready shorter peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4},
-			},
-			args:       args{height: 5},
-			wantResult: "",
-			wantError:  true,
-		},
-		{
-			name: "one Ready equal peer",
-			fields: scTestParams{peers: map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB: []int64{1, 2, 3, 4},
-			},
-			args:       args{height: 4},
-			wantResult: "P1",
-		},
-		{
-			name: "one Ready higher peer",
-			fields: scTestParams{peers: map[string]*scPeer{"P1": {height: 6, state: peerStateReady}},
-				allB: []int64{1, 2, 3, 4, 5, 6},
-			},
-			args:       args{height: 4},
-			wantResult: "P1",
-		},
-		{
-			name: "one Ready higher peer with higher base",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {base: 4, height: 6, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4, 5, 6},
-			},
-			args:       args{height: 3},
-			wantResult: "",
-			wantError:  true,
-		},
-		{
-			name: "many Ready higher peers with different number of pending requests",
-			fields: scTestParams{
-				height: 4,
-				peers: map[string]*scPeer{
-					"P1": {height: 8, state: peerStateReady},
-					"P2": {height: 9, state: peerStateReady}},
-				allB: []int64{4, 5, 6, 7, 8, 9},
-				pending: map[int64]types.NodeID{
-					4: "P1", 6: "P1",
-					5: "P2",
-				},
-			},
-			args:       args{height: 4},
-			wantResult: "P2",
-		},
-		{
-			name: "many Ready higher peers with same number of pending requests",
-			fields: scTestParams{
-				peers: map[string]*scPeer{
-					"P2": {height: 20, state: peerStateReady},
-					"P1": {height: 15, state: peerStateReady},
-					"P3": {height: 15, state: peerStateReady}},
-				allB: []int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
-				pending: map[int64]types.NodeID{
-					1: "P1", 2: "P1",
-					3: "P3", 4: "P3",
-					5: "P2", 6: "P2",
-				},
-			},
-			args:       args{height: 7},
-			wantResult: "P1",
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			// selectPeer should not mutate the scheduler
-			wantSc := sc
-			res, err := sc.selectPeer(tt.args.height)
-			assert.Equal(t, tt.wantResult, res)
-			assert.Equal(t, tt.wantError, err != nil)
-			checkSameScheduler(t, wantSc, sc)
-		})
-	}
-}
-
-// makeScBlock makes an empty block.
-func makeScBlock(height int64) *types.Block {
-	return &types.Block{Header: types.Header{Height: height}}
-}
-
-// used in place of assert.Equal(t, want, actual) to avoid failures due to
-// scheduler.lastAdvanced timestamp inequalities.
-func checkSameScheduler(t *testing.T, want *scheduler, actual *scheduler) {
-	assert.Equal(t, want.initHeight, actual.initHeight)
-	assert.Equal(t, want.height, actual.height)
-	assert.Equal(t, want.peers, actual.peers)
-	assert.Equal(t, want.blockStates, actual.blockStates)
-	assert.Equal(t, want.pendingBlocks, actual.pendingBlocks)
-	assert.Equal(t, want.pendingTime, actual.pendingTime)
-	assert.Equal(t, want.blockStates, actual.blockStates)
-	assert.Equal(t, want.receivedBlocks, actual.receivedBlocks)
-	assert.Equal(t, want.blockStates, actual.blockStates)
-}
-
-// checkScResults checks scheduler handler test results
-func checkScResults(t *testing.T, wantErr bool, err error, wantEvent Event, event Event) {
-	if (err != nil) != wantErr {
-		t.Errorf("error = %v, wantErr %v", err, wantErr)
-		return
-	}
-	if !assert.IsType(t, wantEvent, event) {
-		t.Log(fmt.Sprintf("Wrong type received, got: %v", event))
-	}
-	switch wantEvent := wantEvent.(type) {
-	case scPeerError:
-		assert.Equal(t, wantEvent.peerID, event.(scPeerError).peerID)
-		assert.Equal(t, wantEvent.reason != nil, event.(scPeerError).reason != nil)
-	case scBlockReceived:
-		assert.Equal(t, wantEvent.peerID, event.(scBlockReceived).peerID)
-		assert.Equal(t, wantEvent.block, event.(scBlockReceived).block)
-	case scSchedulerFail:
-		assert.Equal(t, wantEvent.reason != nil, event.(scSchedulerFail).reason != nil)
-	}
-}
-
-func TestScHandleBlockResponse(t *testing.T) {
-	now := time.Now()
-	block6FromP1 := bcBlockResponse{
-		time:   now.Add(time.Millisecond),
-		peerID: types.NodeID("P1"),
-		size:   100,
-		block:  makeScBlock(6),
-	}
-
-	type args struct {
-		event bcBlockResponse
-	}
-
-	tests := []struct {
-		name      string
-		fields    scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-	}{
-		{
-			name:      "empty scheduler",
-			fields:    scTestParams{},
-			args:      args{event: block6FromP1},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name:      "block from removed peer",
-			fields:    scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
-			args:      args{event: block6FromP1},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "block we haven't asked for",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4, 5, 6, 7, 8}},
-			args:      args{event: block6FromP1},
-			wantEvent: scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
-		},
-		{
-			name: "block from wrong peer",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P2"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-			args:      args{event: block6FromP1},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "block with bad timestamp",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P1"},
-				pendingTime: map[int64]time.Time{6: now.Add(time.Second)},
-			},
-			args:      args{event: block6FromP1},
-			wantEvent: scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
-		},
-		{
-			name: "good block, accept",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P1"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-			args:      args{event: block6FromP1},
-			wantEvent: scBlockReceived{peerID: "P1", block: block6FromP1.block},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleBlockResponse(tt.args.event)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-		})
-	}
-}
-
-func TestScHandleNoBlockResponse(t *testing.T) {
-	now := time.Now()
-	noBlock6FromP1 := bcNoBlockResponse{
-		time:   now.Add(time.Millisecond),
-		peerID: types.NodeID("P1"),
-		height: 6,
-	}
-
-	tests := []struct {
-		name       string
-		fields     scTestParams
-		wantEvent  Event
-		wantFields scTestParams
-		wantErr    bool
-	}{
-		{
-			name:       "empty scheduler",
-			fields:     scTestParams{},
-			wantEvent:  noOpEvent{},
-			wantFields: scTestParams{},
-		},
-		{
-			name:       "noBlock from removed peer",
-			fields:     scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
-			wantEvent:  noOpEvent{},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
-		},
-		{
-			name: "for block we haven't asked for",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4, 5, 6, 7, 8}},
-			wantEvent:  scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
-		},
-		{
-			name: "noBlock from peer we don't have",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P2"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-			wantEvent: noOpEvent{},
-			wantFields: scTestParams{
-				peers:       map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P2"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-		},
-		{
-			name: "noBlock from existing peer",
-			fields: scTestParams{
-				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:        []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P1"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-			wantEvent:  scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
-			wantFields: scTestParams{peers: map[string]*scPeer{"P1": {height: 8, state: peerStateRemoved}}},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleNoBlockResponse(noBlock6FromP1)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-			wantSc := newTestScheduler(tt.wantFields)
-			assert.Equal(t, wantSc, sc)
-		})
-	}
-}
-
-func TestScHandleBlockProcessed(t *testing.T) {
-	now := time.Now()
-	processed6FromP1 := pcBlockProcessed{
-		peerID: types.NodeID("P1"),
-		height: 6,
-	}
-
-	type args struct {
-		event pcBlockProcessed
-	}
-
-	tests := []struct {
-		name      string
-		fields    scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-	}{
-		{
-			name:      "empty scheduler",
-			fields:    scTestParams{height: 6},
-			args:      args{event: processed6FromP1},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "processed block we don't have",
-			fields: scTestParams{
-				initHeight:  6,
-				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:        []int64{6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P1"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-			args:      args{event: processed6FromP1},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "processed block ok, we processed all blocks",
-			fields: scTestParams{
-				initHeight: 6,
-				peers:      map[string]*scPeer{"P1": {height: 7, state: peerStateReady}},
-				allB:       []int64{6, 7},
-				received:   map[int64]types.NodeID{6: "P1", 7: "P1"},
-			},
-			args:      args{event: processed6FromP1},
-			wantEvent: scFinishedEv{},
-		},
-		{
-			name: "processed block ok, we still have blocks to process",
-			fields: scTestParams{
-				initHeight: 6,
-				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:       []int64{6, 7, 8},
-				pending:    map[int64]types.NodeID{7: "P1", 8: "P1"},
-				received:   map[int64]types.NodeID{6: "P1"},
-			},
-			args:      args{event: processed6FromP1},
-			wantEvent: noOpEvent{},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleBlockProcessed(tt.args.event)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-		})
-	}
-}
-
-func TestScHandleBlockVerificationFailure(t *testing.T) {
-	now := time.Now()
-
-	type args struct {
-		event pcBlockVerificationFailure
-	}
-
-	tests := []struct {
-		name      string
-		fields    scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-	}{
-		{
-			name:      "empty scheduler",
-			fields:    scTestParams{},
-			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "failed block we don't have, single peer is still removed",
-			fields: scTestParams{
-				initHeight:  6,
-				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:        []int64{6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P1"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
-			wantEvent: scFinishedEv{},
-		},
-		{
-			name: "failed block we don't have, one of two peers are removed",
-			fields: scTestParams{
-				initHeight:  6,
-				peers:       map[string]*scPeer{"P1": {height: 8, state: peerStateReady}, "P2": {height: 8, state: peerStateReady}},
-				allB:        []int64{6, 7, 8},
-				pending:     map[int64]types.NodeID{6: "P1"},
-				pendingTime: map[int64]time.Time{6: now},
-			},
-			args:      args{event: pcBlockVerificationFailure{height: 10, firstPeerID: "P1", secondPeerID: "P1"}},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "failed block, all blocks are processed after removal",
-			fields: scTestParams{
-				initHeight: 6,
-				peers:      map[string]*scPeer{"P1": {height: 7, state: peerStateReady}},
-				allB:       []int64{6, 7},
-				received:   map[int64]types.NodeID{6: "P1", 7: "P1"},
-			},
-			args:      args{event: pcBlockVerificationFailure{height: 7, firstPeerID: "P1", secondPeerID: "P1"}},
-			wantEvent: scFinishedEv{},
-		},
-		{
-			name: "failed block, we still have blocks to process",
-			fields: scTestParams{
-				initHeight: 5,
-				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}, "P2": {height: 8, state: peerStateReady}},
-				allB:       []int64{5, 6, 7, 8},
-				pending:    map[int64]types.NodeID{7: "P1", 8: "P1"},
-				received:   map[int64]types.NodeID{5: "P1", 6: "P1"},
-			},
-			args:      args{event: pcBlockVerificationFailure{height: 5, firstPeerID: "P1", secondPeerID: "P1"}},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "failed block, H+1 and H+2 delivered by different peers, we still have blocks to process",
-			fields: scTestParams{
-				initHeight: 5,
-				peers: map[string]*scPeer{
-					"P1": {height: 8, state: peerStateReady},
-					"P2": {height: 8, state: peerStateReady},
-					"P3": {height: 8, state: peerStateReady},
-				},
-				allB:     []int64{5, 6, 7, 8},
-				pending:  map[int64]types.NodeID{7: "P1", 8: "P1"},
-				received: map[int64]types.NodeID{5: "P1", 6: "P1"},
-			},
-			args:      args{event: pcBlockVerificationFailure{height: 5, firstPeerID: "P1", secondPeerID: "P2"}},
-			wantEvent: noOpEvent{},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleBlockProcessError(tt.args.event)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-		})
-	}
-}
-
-func TestScHandleAddNewPeer(t *testing.T) {
-	addP1 := bcAddNewPeer{
-		peerID: types.NodeID("P1"),
-	}
-	type args struct {
-		event bcAddNewPeer
-	}
-
-	tests := []struct {
-		name      string
-		fields    scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-	}{
-		{
-			name:      "add P1 to empty scheduler",
-			fields:    scTestParams{},
-			args:      args{event: addP1},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "add duplicate peer",
-			fields: scTestParams{
-				initHeight: 6,
-				peers:      map[string]*scPeer{"P1": {height: 8, state: peerStateReady}},
-				allB:       []int64{6, 7, 8},
-			},
-			args:      args{event: addP1},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "add P1 to non empty scheduler",
-			fields: scTestParams{
-				initHeight: 6,
-				peers:      map[string]*scPeer{"P2": {height: 8, state: peerStateReady}},
-				allB:       []int64{6, 7, 8},
-			},
-			args:      args{event: addP1},
-			wantEvent: noOpEvent{},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleAddNewPeer(tt.args.event)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-		})
-	}
-}
-
-func TestScHandleTryPrunePeer(t *testing.T) {
-	now := time.Now()
-
-	pruneEv := rTryPrunePeer{
-		time: now.Add(time.Second + time.Millisecond),
-	}
-	type args struct {
-		event rTryPrunePeer
-	}
-
-	tests := []struct {
-		name      string
-		fields    scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-	}{
-		{
-			name:      "no peers",
-			fields:    scTestParams{},
-			args:      args{event: pruneEv},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "no prunable peers",
-			fields: scTestParams{
-				minRecvRate: 100,
-				peers: map[string]*scPeer{
-					// X - removed, active, fast
-					"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101},
-					// X - ready, active, fast
-					"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101},
-					// X - removed, active, equal
-					"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100}},
-				peerTimeout: time.Second,
-			},
-			args:      args{event: pruneEv},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "mixed peers",
-			fields: scTestParams{
-				minRecvRate: 100,
-				peers: map[string]*scPeer{
-					// X - removed, active, fast
-					"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
-					// X - ready, active, fast
-					"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
-					// X - removed, active, equal
-					"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100, height: 5},
-					// V - ready, inactive, equal
-					"P4": {state: peerStateReady, lastTouched: now, lastRate: 100, height: 7},
-					// V - ready, inactive, slow
-					"P5": {state: peerStateReady, lastTouched: now, lastRate: 99, height: 7},
-					//  V - ready, active, slow
-					"P6": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 90, height: 7},
-				},
-				allB:        []int64{1, 2, 3, 4, 5, 6, 7},
-				peerTimeout: time.Second},
-			args:      args{event: pruneEv},
-			wantEvent: scPeersPruned{peers: []types.NodeID{"P4", "P5", "P6"}},
-		},
-		{
-			name: "mixed peers, finish after pruning",
-			fields: scTestParams{
-				minRecvRate: 100,
-				height:      6,
-				peers: map[string]*scPeer{
-					// X - removed, active, fast
-					"P1": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
-					// X - ready, active, fast
-					"P2": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 101, height: 5},
-					// X - removed, active, equal
-					"P3": {state: peerStateRemoved, lastTouched: now.Add(time.Second), lastRate: 100, height: 5},
-					// V - ready, inactive, equal
-					"P4": {state: peerStateReady, lastTouched: now, lastRate: 100, height: 7},
-					// V - ready, inactive, slow
-					"P5": {state: peerStateReady, lastTouched: now, lastRate: 99, height: 7},
-					//  V - ready, active, slow
-					"P6": {state: peerStateReady, lastTouched: now.Add(time.Second), lastRate: 90, height: 7},
-				},
-				allB:        []int64{6, 7},
-				peerTimeout: time.Second},
-			args:      args{event: pruneEv},
-			wantEvent: scFinishedEv{},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleTryPrunePeer(tt.args.event)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-		})
-	}
-}
-
-func TestScHandleTrySchedule(t *testing.T) {
-	now := time.Now()
-	tryEv := rTrySchedule{
-		time: now.Add(time.Second + time.Millisecond),
-	}
-
-	type args struct {
-		event rTrySchedule
-	}
-	tests := []struct {
-		name      string
-		fields    scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-	}{
-		{
-			name:      "no peers",
-			fields:    scTestParams{startTime: now, peers: map[string]*scPeer{}},
-			args:      args{event: tryEv},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name:      "only new peers",
-			fields:    scTestParams{startTime: now, peers: map[string]*scPeer{"P1": {height: -1, state: peerStateNew}}},
-			args:      args{event: tryEv},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name:      "only Removed peers",
-			fields:    scTestParams{startTime: now, peers: map[string]*scPeer{"P1": {height: 4, state: peerStateRemoved}}},
-			args:      args{event: tryEv},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "one Ready shorter peer",
-			fields: scTestParams{
-				startTime: now,
-				height:    6,
-				peers:     map[string]*scPeer{"P1": {height: 4, state: peerStateReady}}},
-			args:      args{event: tryEv},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "one Ready equal peer",
-			fields: scTestParams{
-				startTime: now,
-				peers:     map[string]*scPeer{"P1": {height: 4, state: peerStateReady}},
-				allB:      []int64{1, 2, 3, 4}},
-			args:      args{event: tryEv},
-			wantEvent: scBlockRequest{peerID: "P1", height: 1},
-		},
-		{
-			name: "many Ready higher peers with different number of pending requests",
-			fields: scTestParams{
-				startTime: now,
-				peers: map[string]*scPeer{
-					"P1": {height: 4, state: peerStateReady},
-					"P2": {height: 5, state: peerStateReady}},
-				allB: []int64{1, 2, 3, 4, 5},
-				pending: map[int64]types.NodeID{
-					1: "P1", 2: "P1",
-					3: "P2",
-				},
-			},
-			args:      args{event: tryEv},
-			wantEvent: scBlockRequest{peerID: "P2", height: 4},
-		},
-
-		{
-			name: "many Ready higher peers with same number of pending requests",
-			fields: scTestParams{
-				startTime: now,
-				peers: map[string]*scPeer{
-					"P2": {height: 8, state: peerStateReady},
-					"P1": {height: 8, state: peerStateReady},
-					"P3": {height: 8, state: peerStateReady}},
-				allB: []int64{1, 2, 3, 4, 5, 6, 7, 8},
-				pending: map[int64]types.NodeID{
-					1: "P1", 2: "P1",
-					3: "P3", 4: "P3",
-					5: "P2", 6: "P2",
-				},
-			},
-			args:      args{event: tryEv},
-			wantEvent: scBlockRequest{peerID: "P1", height: 7},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleTrySchedule(tt.args.event)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-		})
-	}
-}
-
-func TestScHandleStatusResponse(t *testing.T) {
-	now := time.Now()
-	statusRespP1Ev := bcStatusResponse{
-		time:   now.Add(time.Second + time.Millisecond),
-		peerID: "P1",
-		height: 6,
-	}
-
-	type args struct {
-		event bcStatusResponse
-	}
-	tests := []struct {
-		name      string
-		fields    scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-	}{
-		{
-			name: "change height of non existing peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P2": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2},
-			},
-			args:      args{event: statusRespP1Ev},
-			wantEvent: noOpEvent{},
-		},
-
-		{
-			name:      "increase height of removed peer",
-			fields:    scTestParams{peers: map[string]*scPeer{"P1": {height: 2, state: peerStateRemoved}}},
-			args:      args{event: statusRespP1Ev},
-			wantEvent: noOpEvent{},
-		},
-
-		{
-			name: "decrease height of single peer",
-			fields: scTestParams{
-				height: 5,
-				peers:  map[string]*scPeer{"P1": {height: 10, state: peerStateReady}},
-				allB:   []int64{5, 6, 7, 8, 9, 10},
-			},
-			args:      args{event: statusRespP1Ev},
-			wantEvent: scPeerError{peerID: "P1", reason: fmt.Errorf("some error")},
-		},
-
-		{
-			name: "increase height of single peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 2, state: peerStateReady}},
-				allB:  []int64{1, 2}},
-			args:      args{event: statusRespP1Ev},
-			wantEvent: noOpEvent{},
-		},
-		{
-			name: "noop height change of single peer",
-			fields: scTestParams{
-				peers: map[string]*scPeer{"P1": {height: 6, state: peerStateReady}},
-				allB:  []int64{1, 2, 3, 4, 5, 6}},
-			args:      args{event: statusRespP1Ev},
-			wantEvent: noOpEvent{},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			sc := newTestScheduler(tt.fields)
-			event, err := sc.handleStatusResponse(tt.args.event)
-			checkScResults(t, tt.wantErr, err, tt.wantEvent, event)
-		})
-	}
-}
-
-func TestScHandle(t *testing.T) {
-	now := time.Now()
-
-	type unknownEv struct {
-		priorityNormal
-	}
-
-	block1, block2, block3 := makeScBlock(1), makeScBlock(2), makeScBlock(3)
-
-	t0 := time.Now()
-	tick := make([]time.Time, 100)
-	for i := range tick {
-		tick[i] = t0.Add(time.Duration(i) * time.Millisecond)
-	}
-
-	type args struct {
-		event Event
-	}
-	type scStep struct {
-		currentSc *scTestParams
-		args      args
-		wantEvent Event
-		wantErr   bool
-		wantSc    *scTestParams
-	}
-	tests := []struct {
-		name  string
-		steps []scStep
-	}{
-		{
-			name: "unknown event",
-			steps: []scStep{
-				{ // add P1
-					currentSc: &scTestParams{},
-					args:      args{event: unknownEv{}},
-					wantEvent: scSchedulerFail{reason: fmt.Errorf("some error")},
-					wantSc:    &scTestParams{},
-				},
-			},
-		},
-		{
-			name: "single peer, sync 3 blocks",
-			steps: []scStep{
-				{ // add P1
-					currentSc: &scTestParams{startTime: now, peers: map[string]*scPeer{}, height: 1},
-					args:      args{event: bcAddNewPeer{peerID: "P1"}},
-					wantEvent: noOpEvent{},
-					wantSc: &scTestParams{startTime: now, peers: map[string]*scPeer{
-						"P1": {base: -1, height: -1, state: peerStateNew}}, height: 1},
-				},
-				{ // set height of P1
-					args:      args{event: bcStatusResponse{peerID: "P1", time: tick[0], height: 3}},
-					wantEvent: noOpEvent{},
-					wantSc: &scTestParams{
-						startTime: now,
-						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
-						allB:      []int64{1, 2, 3},
-						height:    1,
-					},
-				},
-				{ // schedule block 1
-					args:      args{event: rTrySchedule{time: tick[1]}},
-					wantEvent: scBlockRequest{peerID: "P1", height: 1},
-					wantSc: &scTestParams{
-						startTime:   now,
-						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
-						allB:        []int64{1, 2, 3},
-						pending:     map[int64]types.NodeID{1: "P1"},
-						pendingTime: map[int64]time.Time{1: tick[1]},
-						height:      1,
-					},
-				},
-				{ // schedule block 2
-					args:      args{event: rTrySchedule{time: tick[2]}},
-					wantEvent: scBlockRequest{peerID: "P1", height: 2},
-					wantSc: &scTestParams{
-						startTime:   now,
-						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
-						allB:        []int64{1, 2, 3},
-						pending:     map[int64]types.NodeID{1: "P1", 2: "P1"},
-						pendingTime: map[int64]time.Time{1: tick[1], 2: tick[2]},
-						height:      1,
-					},
-				},
-				{ // schedule block 3
-					args:      args{event: rTrySchedule{time: tick[3]}},
-					wantEvent: scBlockRequest{peerID: "P1", height: 3},
-					wantSc: &scTestParams{
-						startTime:   now,
-						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady}},
-						allB:        []int64{1, 2, 3},
-						pending:     map[int64]types.NodeID{1: "P1", 2: "P1", 3: "P1"},
-						pendingTime: map[int64]time.Time{1: tick[1], 2: tick[2], 3: tick[3]},
-						height:      1,
-					},
-				},
-				{ // block response 1
-					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[4], size: 100, block: block1}},
-					wantEvent: scBlockReceived{peerID: "P1", block: block1},
-					wantSc: &scTestParams{
-						startTime:   now,
-						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[4]}},
-						allB:        []int64{1, 2, 3},
-						pending:     map[int64]types.NodeID{2: "P1", 3: "P1"},
-						pendingTime: map[int64]time.Time{2: tick[2], 3: tick[3]},
-						received:    map[int64]types.NodeID{1: "P1"},
-						height:      1,
-					},
-				},
-				{ // block response 2
-					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[5], size: 100, block: block2}},
-					wantEvent: scBlockReceived{peerID: "P1", block: block2},
-					wantSc: &scTestParams{
-						startTime:   now,
-						peers:       map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[5]}},
-						allB:        []int64{1, 2, 3},
-						pending:     map[int64]types.NodeID{3: "P1"},
-						pendingTime: map[int64]time.Time{3: tick[3]},
-						received:    map[int64]types.NodeID{1: "P1", 2: "P1"},
-						height:      1,
-					},
-				},
-				{ // block response 3
-					args:      args{event: bcBlockResponse{peerID: "P1", time: tick[6], size: 100, block: block3}},
-					wantEvent: scBlockReceived{peerID: "P1", block: block3},
-					wantSc: &scTestParams{
-						startTime: now,
-						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
-						allB:      []int64{1, 2, 3},
-						received:  map[int64]types.NodeID{1: "P1", 2: "P1", 3: "P1"},
-						height:    1,
-					},
-				},
-				{ // processed block 1
-					args:      args{event: pcBlockProcessed{peerID: types.NodeID("P1"), height: 1}},
-					wantEvent: noOpEvent{},
-					wantSc: &scTestParams{
-						startTime: now,
-						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
-						allB:      []int64{2, 3},
-						received:  map[int64]types.NodeID{2: "P1", 3: "P1"},
-						height:    2,
-					},
-				},
-				{ // processed block 2
-					args:      args{event: pcBlockProcessed{peerID: types.NodeID("P1"), height: 2}},
-					wantEvent: scFinishedEv{},
-					wantSc: &scTestParams{
-						startTime: now,
-						peers:     map[string]*scPeer{"P1": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
-						allB:      []int64{3},
-						received:  map[int64]types.NodeID{3: "P1"},
-						height:    3,
-					},
-				},
-			},
-		},
-		{
-			name: "block verification failure",
-			steps: []scStep{
-				{ // failure processing block 1
-					currentSc: &scTestParams{
-						startTime: now,
-						peers: map[string]*scPeer{
-							"P1": {height: 4, state: peerStateReady, lastTouched: tick[6]},
-							"P2": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
-						allB:     []int64{1, 2, 3, 4},
-						received: map[int64]types.NodeID{1: "P1", 2: "P1", 3: "P1"},
-						height:   1,
-					},
-					args:      args{event: pcBlockVerificationFailure{height: 1, firstPeerID: "P1", secondPeerID: "P1"}},
-					wantEvent: noOpEvent{},
-					wantSc: &scTestParams{
-						startTime: now,
-						peers: map[string]*scPeer{
-							"P1": {height: 4, state: peerStateRemoved, lastTouched: tick[6]},
-							"P2": {height: 3, state: peerStateReady, lastTouched: tick[6]}},
-						allB:     []int64{1, 2, 3},
-						received: map[int64]types.NodeID{},
-						height:   1,
-					},
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			var sc *scheduler
-			for i, step := range tt.steps {
-				// First step must always initialize the currentState as state.
-				if step.currentSc != nil {
-					sc = newTestScheduler(*step.currentSc)
-				}
-				if sc == nil {
-					panic("Bad (initial?) step")
-				}
-
-				nextEvent, err := sc.handle(step.args.event)
-				wantSc := newTestScheduler(*step.wantSc)
-
-				t.Logf("step %d(%v): %s", i, step.args.event, sc)
-				checkSameScheduler(t, wantSc, sc)
-
-				checkScResults(t, step.wantErr, err, step.wantEvent, nextEvent)
-
-				// Next step may use the wantedState as their currentState.
-				sc = newTestScheduler(*step.wantSc)
-			}
-		})
-	}
-}
diff --git a/internal/blocksync/v2/types.go b/internal/blocksync/v2/types.go
deleted file mode 100644
index 7a73728e46..0000000000
--- a/internal/blocksync/v2/types.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package v2
-
-import (
-	"github.com/Workiva/go-datastructures/queue"
-)
-
-// Event is the type that can be added to the priority queue.
-type Event queue.Item
-
-type priority interface {
-	Compare(other queue.Item) int
-	Priority() int
-}
-
-type priorityLow struct{}
-type priorityNormal struct{}
-type priorityHigh struct{}
-
-func (p priorityLow) Priority() int {
-	return 1
-}
-
-func (p priorityNormal) Priority() int {
-	return 2
-}
-
-func (p priorityHigh) Priority() int {
-	return 3
-}
-
-func (p priorityLow) Compare(other queue.Item) int {
-	op := other.(priority)
-	if p.Priority() > op.Priority() {
-		return 1
-	} else if p.Priority() == op.Priority() {
-		return 0
-	}
-	return -1
-}
-
-func (p priorityNormal) Compare(other queue.Item) int {
-	op := other.(priority)
-	if p.Priority() > op.Priority() {
-		return 1
-	} else if p.Priority() == op.Priority() {
-		return 0
-	}
-	return -1
-}
-
-func (p priorityHigh) Compare(other queue.Item) int {
-	op := other.(priority)
-	if p.Priority() > op.Priority() {
-		return 1
-	} else if p.Priority() == op.Priority() {
-		return 0
-	}
-	return -1
-}
-
-type noOpEvent struct {
-	priorityLow
-}
-
-var noOp = noOpEvent{}
diff --git a/node/node.go b/node/node.go
index fc43aace48..820e0630aa 100644
--- a/node/node.go
+++ b/node/node.go
@@ -640,7 +640,7 @@ func (n *nodeImpl) OnStart() error {
 	}
 
 	if n.config.Mode != config.ModeSeed {
-		if n.config.BlockSync.Version == config.BlockSyncV0 {
+		if n.config.BlockSync.Enable {
 			if err := n.bcReactor.Start(); err != nil {
 				return err
 			}
@@ -762,7 +762,7 @@ func (n *nodeImpl) OnStop() {
 
 	if n.config.Mode != config.ModeSeed {
 		// now stop the reactors
-		if n.config.BlockSync.Version == config.BlockSyncV0 {
+		if n.config.BlockSync.Enable {
 			// Stop the real blockchain reactor separately since the switch uses the shim.
 			if err := n.bcReactor.Stop(); err != nil {
 				n.Logger.Error("failed to stop the blockchain reactor", "err", err)
diff --git a/node/setup.go b/node/setup.go
index 3f305125d4..16aa715c9b 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -3,7 +3,6 @@ package node
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"math"
 	"net"
@@ -16,7 +15,6 @@ import (
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
 	bcv0 "github.com/tendermint/tendermint/internal/blocksync/v0"
-	bcv2 "github.com/tendermint/tendermint/internal/blocksync/v2"
 	"github.com/tendermint/tendermint/internal/consensus"
 	"github.com/tendermint/tendermint/internal/evidence"
 	"github.com/tendermint/tendermint/internal/mempool"
@@ -295,40 +293,31 @@ func createBlockchainReactor(
 
 	logger = logger.With("module", "blockchain")
 
-	switch cfg.BlockSync.Version {
-	case config.BlockSyncV0:
-		reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", bcv0.ChannelShims)
+	reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", bcv0.ChannelShims)
 
-		var (
-			channels    map[p2p.ChannelID]*p2p.Channel
-			peerUpdates *p2p.PeerUpdates
-		)
-
-		if cfg.P2P.UseLegacy {
-			channels = getChannelsFromShim(reactorShim)
-			peerUpdates = reactorShim.PeerUpdates
-		} else {
-			channels = makeChannelsFromShims(router, bcv0.ChannelShims)
-			peerUpdates = peerManager.Subscribe()
-		}
-
-		reactor, err := bcv0.NewReactor(
-			logger, state.Copy(), blockExec, blockStore, csReactor,
-			channels[bcv0.BlockSyncChannel], peerUpdates, blockSync,
-			metrics,
-		)
-		if err != nil {
-			return nil, nil, err
-		}
-
-		return reactorShim, reactor, nil
+	var (
+		channels    map[p2p.ChannelID]*p2p.Channel
+		peerUpdates *p2p.PeerUpdates
+	)
 
-	case config.BlockSyncV2:
-		return nil, nil, errors.New("block sync version v2 is no longer supported. Please use v0")
+	if cfg.P2P.UseLegacy {
+		channels = getChannelsFromShim(reactorShim)
+		peerUpdates = reactorShim.PeerUpdates
+	} else {
+		channels = makeChannelsFromShims(router, bcv0.ChannelShims)
+		peerUpdates = peerManager.Subscribe()
+	}
 
-	default:
-		return nil, nil, fmt.Errorf("unknown block sync version %s", cfg.BlockSync.Version)
+	reactor, err := bcv0.NewReactor(
+		logger, state.Copy(), blockExec, blockStore, csReactor,
+		channels[bcv0.BlockSyncChannel], peerUpdates, blockSync,
+		metrics,
+	)
+	if err != nil {
+		return nil, nil, err
 	}
+
+	return reactorShim, reactor, nil
 }
 
 func createConsensusReactor(
@@ -676,17 +665,7 @@ func makeNodeInfo(
 		txIndexerStatus = "on"
 	}
 
-	var bcChannel byte
-	switch cfg.BlockSync.Version {
-	case config.BlockSyncV0:
-		bcChannel = byte(bcv0.BlockSyncChannel)
-
-	case config.BlockSyncV2:
-		bcChannel = bcv2.BlockchainChannel
-
-	default:
-		return types.NodeInfo{}, fmt.Errorf("unknown blocksync version %s", cfg.BlockSync.Version)
-	}
+	bcChannel := byte(bcv0.BlockSyncChannel)
 
 	nodeInfo := types.NodeInfo{
 		ProtocolVersion: types.ProtocolVersion{
diff --git a/test/e2e/networks/ci.toml b/test/e2e/networks/ci.toml
index 7e07febd5a..6eb32e56fd 100644
--- a/test/e2e/networks/ci.toml
+++ b/test/e2e/networks/ci.toml
@@ -35,6 +35,7 @@ perturb = ["restart"]
 perturb = ["disconnect"]
 seeds = ["seed01"]
 snapshot_interval = 5
+block_sync = "v0"
 
 [node.validator02]
 abci_protocol = "tcp"
diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go
index 3af7a99448..5a8407ab2c 100644
--- a/test/e2e/runner/setup.go
+++ b/test/e2e/runner/setup.go
@@ -296,10 +296,9 @@ func MakeConfig(node *e2e.Node) (*config.Config, error) {
 		cfg.Mempool.Version = node.Mempool
 	}
 
+	cfg.BlockSync.Enable = true
 	if node.BlockSync == "" {
 		cfg.BlockSync.Enable = false
-	} else {
-		cfg.BlockSync.Version = node.BlockSync
 	}
 
 	switch node.StateSync {

From f5b9c210ca1b2cf1c2303038b14a2588604a4af3 Mon Sep 17 00:00:00 2001
From: William Banfield <4561443+williambanfield@users.noreply.github.com>
Date: Mon, 4 Oct 2021 18:37:18 -0400
Subject: [PATCH 17/57] consensus: wait until peerUpdates channel is closed to
 close remaining peers (#7058)

The race occurred as a result of a goroutine launched by `processPeerUpdate` racing with the `OnStop` method. The `processPeerUpdates` goroutine deletes from the map as `OnStop` is reading from it. This change updates the `OnStop` method to wait for the peer updates channel to be done before closing the peers. It also copies the map contents to a new map so that it will not conflict with the view of the map that the goroutine created in `processPeerUpdate` sees.
---
 internal/consensus/reactor.go | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go
index ca3f5d3536..22bd7576ea 100644
--- a/internal/consensus/reactor.go
+++ b/internal/consensus/reactor.go
@@ -230,16 +230,14 @@ func (r *Reactor) OnStop() {
 	}
 
 	r.mtx.Lock()
-	peers := r.peers
-	r.mtx.Unlock()
-
-	// wait for all spawned peer goroutines to gracefully exit
-	for _, ps := range peers {
-		ps.closer.Close()
-	}
-	for _, ps := range peers {
-		ps.broadcastWG.Wait()
+	// Close and wait for each of the peers to shutdown.
+	// This is safe to perform with the lock since none of the peers require the
+	// lock to complete any of the methods that the waitgroup is waiting on.
+	for _, state := range r.peers {
+		state.closer.Close()
+		state.broadcastWG.Wait()
 	}
+	r.mtx.Unlock()
 
 	// Close the StateChannel goroutine separately since it uses its own channel
 	// to signal closure.

From 03ad7d6f20d9fd8fe83d31db168f433480552e94 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 5 Oct 2021 09:40:32 -0400
Subject: [PATCH 18/57] p2p: delete legacy stack initial pass (#7035)

A few notes:

- this is not all the deletion that we can do, but this is the most
  "simple" case: it leaves in shims, and there's some trivial
  additional cleanup to the transport that can happen but that
  requires writing more code, and I wanted this to be easy to review
  above all else.

- This should land *after* we cut the branch for 0.35, but I'm
  anticipating that to happen soon, and I wanted to run this through
  CI.
---
 CHANGELOG_PENDING.md                        |    7 +
 config/config.go                            |    6 -
 config/toml.go                              |    3 -
 docs/nodes/configuration.md                 |    3 -
 internal/p2p/base_reactor.go                |   74 -
 internal/p2p/conn/secret_connection_test.go |    2 +-
 internal/p2p/mock/reactor.go                |   23 -
 internal/p2p/peer.go                        |  371 ----
 internal/p2p/peer_set.go                    |  149 --
 internal/p2p/peer_set_test.go               |  190 ---
 internal/p2p/peer_test.go                   |  239 ---
 internal/p2p/pex/addrbook.go                |  948 -----------
 internal/p2p/pex/addrbook_test.go           |  777 ---------
 internal/p2p/pex/bench_test.go              |   24 -
 internal/p2p/pex/errors.go                  |   11 -
 internal/p2p/pex/file.go                    |   83 -
 internal/p2p/pex/known_address.go           |  141 --
 internal/p2p/pex/params.go                  |   55 -
 internal/p2p/pex/pex_reactor.go             |  862 ----------
 internal/p2p/pex/pex_reactor_test.go        |  680 --------
 internal/p2p/pex/reactor.go                 |   16 +
 internal/p2p/router.go                      |    4 +-
 internal/p2p/shim.go                        |  303 +---
 internal/p2p/shim_test.go                   |  207 ---
 internal/p2p/switch.go                      | 1064 ------------
 internal/p2p/switch_test.go                 |  932 ----------
 internal/p2p/test_util.go                   |  256 ---
 internal/p2p/transport.go                   |    9 -
 internal/rpc/core/consensus.go              |   60 +-
 internal/rpc/core/env.go                    |    9 -
 internal/rpc/core/net.go                    |  115 +-
 internal/rpc/core/net_test.go               |   89 -
 internal/rpc/core/routes.go                 |    2 -
 internal/rpc/core/status.go                 |    1 +
 node/node.go                                |  166 +-
 node/setup.go                               |  194 +--
 rpc/client/local/local.go                   |   14 -
 rpc/client/mock/client.go                   |   14 -
 test/e2e/generator/generate.go              |   91 +-
 test/e2e/generator/generate_test.go         |   72 +-
 test/e2e/generator/main.go                  |   16 -
 test/e2e/networks/ci.toml                   |    1 -
 test/e2e/pkg/manifest.go                    |    3 -
 test/e2e/pkg/testnet.go                     |    2 -
 test/e2e/runner/setup.go                    |    2 -
 test/fuzz/p2p/addrbook/fuzz.go              |   35 -
 test/fuzz/p2p/addrbook/fuzz_test.go         |   33 -
 test/fuzz/p2p/addrbook/init-corpus/main.go  |   59 -
 test/fuzz/p2p/addrbook/testdata/cases/empty |    0
 test/fuzz/p2p/pex/fuzz_test.go              |   33 -
 test/fuzz/p2p/pex/init-corpus/main.go       |   84 -
 test/fuzz/p2p/pex/reactor_receive.go        |   95 --
 test/fuzz/p2p/pex/testdata/addrbook1        | 1705 -------------------
 test/fuzz/p2p/pex/testdata/cases/empty      |    0
 54 files changed, 127 insertions(+), 10207 deletions(-)
 delete mode 100644 internal/p2p/base_reactor.go
 delete mode 100644 internal/p2p/mock/reactor.go
 delete mode 100644 internal/p2p/peer.go
 delete mode 100644 internal/p2p/peer_set.go
 delete mode 100644 internal/p2p/peer_set_test.go
 delete mode 100644 internal/p2p/peer_test.go
 delete mode 100644 internal/p2p/pex/addrbook.go
 delete mode 100644 internal/p2p/pex/addrbook_test.go
 delete mode 100644 internal/p2p/pex/bench_test.go
 delete mode 100644 internal/p2p/pex/file.go
 delete mode 100644 internal/p2p/pex/known_address.go
 delete mode 100644 internal/p2p/pex/params.go
 delete mode 100644 internal/p2p/pex/pex_reactor.go
 delete mode 100644 internal/p2p/pex/pex_reactor_test.go
 delete mode 100644 internal/p2p/shim_test.go
 delete mode 100644 internal/p2p/switch.go
 delete mode 100644 internal/p2p/switch_test.go
 delete mode 100644 internal/rpc/core/net_test.go
 delete mode 100644 test/fuzz/p2p/addrbook/fuzz.go
 delete mode 100644 test/fuzz/p2p/addrbook/fuzz_test.go
 delete mode 100644 test/fuzz/p2p/addrbook/init-corpus/main.go
 delete mode 100644 test/fuzz/p2p/addrbook/testdata/cases/empty
 delete mode 100644 test/fuzz/p2p/pex/fuzz_test.go
 delete mode 100644 test/fuzz/p2p/pex/init-corpus/main.go
 delete mode 100644 test/fuzz/p2p/pex/reactor_receive.go
 delete mode 100644 test/fuzz/p2p/pex/testdata/addrbook1
 delete mode 100644 test/fuzz/p2p/pex/testdata/cases/empty

diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md
index 56efd763b3..0a4c90f400 100644
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -16,8 +16,15 @@ Special thanks to external contributors on this release:
 
 - P2P Protocol
 
+  - [p2p] \#7035 Remove legacy P2P routing implementation and
+    associated configuration (@tychoish)
+
 - Go API
 
+  - [blocksync] \#7046 Remove v2 implementation of the blocksync
+    service and recactor, which was disabled in the previous release
+    (@tychoish)
+
 - Blockchain Protocol
 
 ### FEATURES
diff --git a/config/config.go b/config/config.go
index 79ce569351..a393e6edc5 100644
--- a/config/config.go
+++ b/config/config.go
@@ -709,11 +709,6 @@ type P2PConfig struct { //nolint: maligned
 	// Force dial to fail
 	TestDialFail bool `mapstructure:"test-dial-fail"`
 
-	// UseLegacy enables the "legacy" P2P implementation and
-	// disables the newer default implementation. This flag will
-	// be removed in a future release.
-	UseLegacy bool `mapstructure:"use-legacy"`
-
 	// Makes it possible to configure which queue backend the p2p
 	// layer uses. Options are: "fifo", "priority" and "wdrr",
 	// with the default being "priority".
@@ -748,7 +743,6 @@ func DefaultP2PConfig() *P2PConfig {
 		DialTimeout:             3 * time.Second,
 		TestDialFail:            false,
 		QueueType:               "priority",
-		UseLegacy:               false,
 	}
 }
 
diff --git a/config/toml.go b/config/toml.go
index 6f07d6537b..ee4c30004d 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -265,9 +265,6 @@ pprof-laddr = "{{ .RPC.PprofListenAddress }}"
 #######################################################
 [p2p]
 
-# Enable the legacy p2p layer.
-use-legacy = {{ .P2P.UseLegacy }}
-
 # Select the p2p internal queue
 queue-type = "{{ .P2P.QueueType }}"
 
diff --git a/docs/nodes/configuration.md b/docs/nodes/configuration.md
index 5695c1a28a..0c11df6f7d 100644
--- a/docs/nodes/configuration.md
+++ b/docs/nodes/configuration.md
@@ -221,9 +221,6 @@ pprof-laddr = ""
 #######################################################
 [p2p]
 
-# Enable the legacy p2p layer.
-use-legacy = false
-
 # Select the p2p internal queue
 queue-type = "priority"
 
diff --git a/internal/p2p/base_reactor.go b/internal/p2p/base_reactor.go
deleted file mode 100644
index 09925caf8d..0000000000
--- a/internal/p2p/base_reactor.go
+++ /dev/null
@@ -1,74 +0,0 @@
-package p2p
-
-import (
-	"github.com/tendermint/tendermint/internal/p2p/conn"
-	"github.com/tendermint/tendermint/libs/service"
-)
-
-// Reactor is responsible for handling incoming messages on one or more
-// Channel. Switch calls GetChannels when reactor is added to it. When a new
-// peer joins our node, InitPeer and AddPeer are called. RemovePeer is called
-// when the peer is stopped. Receive is called when a message is received on a
-// channel associated with this reactor.
-//
-// Peer#Send or Peer#TrySend should be used to send the message to a peer.
-type Reactor interface {
-	service.Service // Start, Stop
-
-	// SetSwitch allows setting a switch.
-	SetSwitch(*Switch)
-
-	// GetChannels returns the list of MConnection.ChannelDescriptor. Make sure
-	// that each ID is unique across all the reactors added to the switch.
-	GetChannels() []*conn.ChannelDescriptor
-
-	// InitPeer is called by the switch before the peer is started. Use it to
-	// initialize data for the peer (e.g. peer state).
-	//
-	// NOTE: The switch won't call AddPeer nor RemovePeer if it fails to start
-	// the peer. Do not store any data associated with the peer in the reactor
-	// itself unless you don't want to have a state, which is never cleaned up.
-	InitPeer(peer Peer) Peer
-
-	// AddPeer is called by the switch after the peer is added and successfully
-	// started. Use it to start goroutines communicating with the peer.
-	AddPeer(peer Peer)
-
-	// RemovePeer is called by the switch when the peer is stopped (due to error
-	// or other reason).
-	RemovePeer(peer Peer, reason interface{})
-
-	// Receive is called by the switch when msgBytes is received from the peer.
-	//
-	// NOTE reactor can not keep msgBytes around after Receive completes without
-	// copying.
-	//
-	// CONTRACT: msgBytes are not nil.
-	//
-	// XXX: do not call any methods that can block or incur heavy processing.
-	// https://github.com/tendermint/tendermint/issues/2888
-	Receive(chID byte, peer Peer, msgBytes []byte)
-}
-
-//--------------------------------------
-
-type BaseReactor struct {
-	service.BaseService // Provides Start, Stop, .Quit
-	Switch              *Switch
-}
-
-func NewBaseReactor(name string, impl Reactor) *BaseReactor {
-	return &BaseReactor{
-		BaseService: *service.NewBaseService(nil, name, impl),
-		Switch:      nil,
-	}
-}
-
-func (br *BaseReactor) SetSwitch(sw *Switch) {
-	br.Switch = sw
-}
-func (*BaseReactor) GetChannels() []*conn.ChannelDescriptor        { return nil }
-func (*BaseReactor) AddPeer(peer Peer)                             {}
-func (*BaseReactor) RemovePeer(peer Peer, reason interface{})      {}
-func (*BaseReactor) Receive(chID byte, peer Peer, msgBytes []byte) {}
-func (*BaseReactor) InitPeer(peer Peer) Peer                       { return peer }
diff --git a/internal/p2p/conn/secret_connection_test.go b/internal/p2p/conn/secret_connection_test.go
index 62587c0da2..84384011b4 100644
--- a/internal/p2p/conn/secret_connection_test.go
+++ b/internal/p2p/conn/secret_connection_test.go
@@ -195,7 +195,7 @@ func TestSecretConnectionReadWrite(t *testing.T) {
 	compareWritesReads := func(writes []string, reads []string) {
 		for {
 			// Pop next write & corresponding reads
-			var read, write string = "", writes[0]
+			var read, write = "", writes[0]
 			var readCount = 0
 			for _, readChunk := range reads {
 				read += readChunk
diff --git a/internal/p2p/mock/reactor.go b/internal/p2p/mock/reactor.go
deleted file mode 100644
index d634a80323..0000000000
--- a/internal/p2p/mock/reactor.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package mock
-
-import (
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
-	"github.com/tendermint/tendermint/libs/log"
-)
-
-type Reactor struct {
-	p2p.BaseReactor
-}
-
-func NewReactor() *Reactor {
-	r := &Reactor{}
-	r.BaseReactor = *p2p.NewBaseReactor("Mock-PEX", r)
-	r.SetLogger(log.TestingLogger())
-	return r
-}
-
-func (r *Reactor) GetChannels() []*conn.ChannelDescriptor            { return []*conn.ChannelDescriptor{} }
-func (r *Reactor) AddPeer(peer p2p.Peer)                             {}
-func (r *Reactor) RemovePeer(peer p2p.Peer, reason interface{})      {}
-func (r *Reactor) Receive(chID byte, peer p2p.Peer, msgBytes []byte) {}
diff --git a/internal/p2p/peer.go b/internal/p2p/peer.go
deleted file mode 100644
index 709a1294a5..0000000000
--- a/internal/p2p/peer.go
+++ /dev/null
@@ -1,371 +0,0 @@
-package p2p
-
-import (
-	"fmt"
-	"io"
-	"net"
-	"runtime/debug"
-	"time"
-
-	tmconn "github.com/tendermint/tendermint/internal/p2p/conn"
-	"github.com/tendermint/tendermint/libs/cmap"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/libs/service"
-	"github.com/tendermint/tendermint/types"
-)
-
-//go:generate ../../scripts/mockery_generate.sh Peer
-
-const metricsTickerDuration = 10 * time.Second
-
-// Peer is an interface representing a peer connected on a reactor.
-type Peer interface {
-	service.Service
-	FlushStop()
-
-	ID() types.NodeID     // peer's cryptographic ID
-	RemoteIP() net.IP     // remote IP of the connection
-	RemoteAddr() net.Addr // remote address of the connection
-
-	IsOutbound() bool   // did we dial the peer
-	IsPersistent() bool // do we redial this peer when we disconnect
-
-	CloseConn() error // close original connection
-
-	NodeInfo() types.NodeInfo // peer's info
-	Status() tmconn.ConnectionStatus
-	SocketAddr() *NetAddress // actual address of the socket
-
-	Send(byte, []byte) bool
-	TrySend(byte, []byte) bool
-
-	Set(string, interface{})
-	Get(string) interface{}
-}
-
-//----------------------------------------------------------
-
-// peerConn contains the raw connection and its config.
-type peerConn struct {
-	outbound   bool
-	persistent bool
-	conn       Connection
-	ip         net.IP // cached RemoteIP()
-}
-
-func newPeerConn(outbound, persistent bool, conn Connection) peerConn {
-	return peerConn{
-		outbound:   outbound,
-		persistent: persistent,
-		conn:       conn,
-	}
-}
-
-// Return the IP from the connection RemoteAddr
-func (pc peerConn) RemoteIP() net.IP {
-	if pc.ip == nil {
-		pc.ip = pc.conn.RemoteEndpoint().IP
-	}
-	return pc.ip
-}
-
-// peer implements Peer.
-//
-// Before using a peer, you will need to perform a handshake on connection.
-type peer struct {
-	service.BaseService
-
-	// raw peerConn and the multiplex connection
-	peerConn
-
-	// peer's node info and the channel it knows about
-	// channels = nodeInfo.Channels
-	// cached to avoid copying nodeInfo in hasChannel
-	nodeInfo    types.NodeInfo
-	channels    []byte
-	reactors    map[byte]Reactor
-	onPeerError func(Peer, interface{})
-
-	// User data
-	Data *cmap.CMap
-
-	metrics       *Metrics
-	metricsTicker *time.Ticker
-}
-
-type PeerOption func(*peer)
-
-func newPeer(
-	nodeInfo types.NodeInfo,
-	pc peerConn,
-	reactorsByCh map[byte]Reactor,
-	onPeerError func(Peer, interface{}),
-	options ...PeerOption,
-) *peer {
-	p := &peer{
-		peerConn:      pc,
-		nodeInfo:      nodeInfo,
-		channels:      nodeInfo.Channels,
-		reactors:      reactorsByCh,
-		onPeerError:   onPeerError,
-		Data:          cmap.NewCMap(),
-		metricsTicker: time.NewTicker(metricsTickerDuration),
-		metrics:       NopMetrics(),
-	}
-
-	p.BaseService = *service.NewBaseService(nil, "Peer", p)
-	for _, option := range options {
-		option(p)
-	}
-
-	return p
-}
-
-// onError calls the peer error callback.
-func (p *peer) onError(err interface{}) {
-	p.onPeerError(p, err)
-}
-
-// String representation.
-func (p *peer) String() string {
-	if p.outbound {
-		return fmt.Sprintf("Peer{%v %v out}", p.conn, p.ID())
-	}
-
-	return fmt.Sprintf("Peer{%v %v in}", p.conn, p.ID())
-}
-
-//---------------------------------------------------
-// Implements service.Service
-
-// SetLogger implements BaseService.
-func (p *peer) SetLogger(l log.Logger) {
-	p.Logger = l
-}
-
-// OnStart implements BaseService.
-func (p *peer) OnStart() error {
-	if err := p.BaseService.OnStart(); err != nil {
-		return err
-	}
-
-	go p.processMessages()
-	go p.metricsReporter()
-
-	return nil
-}
-
-// processMessages processes messages received from the connection.
-func (p *peer) processMessages() {
-	defer func() {
-		if r := recover(); r != nil {
-			p.Logger.Error("peer message processing panic", "err", r, "stack", string(debug.Stack()))
-			p.onError(fmt.Errorf("panic during peer message processing: %v", r))
-		}
-	}()
-
-	for {
-		chID, msg, err := p.conn.ReceiveMessage()
-		if err != nil {
-			p.onError(err)
-			return
-		}
-		reactor, ok := p.reactors[byte(chID)]
-		if !ok {
-			p.onError(fmt.Errorf("unknown channel %v", chID))
-			return
-		}
-		reactor.Receive(byte(chID), p, msg)
-	}
-}
-
-// FlushStop mimics OnStop but additionally ensures that all successful
-// .Send() calls will get flushed before closing the connection.
-// NOTE: it is not safe to call this method more than once.
-func (p *peer) FlushStop() {
-	p.metricsTicker.Stop()
-	p.BaseService.OnStop()
-	if err := p.conn.FlushClose(); err != nil {
-		p.Logger.Debug("error while stopping peer", "err", err)
-	}
-}
-
-// OnStop implements BaseService.
-func (p *peer) OnStop() {
-	p.metricsTicker.Stop()
-	p.BaseService.OnStop()
-	if err := p.conn.Close(); err != nil {
-		p.Logger.Debug("error while stopping peer", "err", err)
-	}
-}
-
-//---------------------------------------------------
-// Implements Peer
-
-// ID returns the peer's ID - the hex encoded hash of its pubkey.
-func (p *peer) ID() types.NodeID {
-	return p.nodeInfo.ID()
-}
-
-// IsOutbound returns true if the connection is outbound, false otherwise.
-func (p *peer) IsOutbound() bool {
-	return p.peerConn.outbound
-}
-
-// IsPersistent returns true if the peer is persitent, false otherwise.
-func (p *peer) IsPersistent() bool {
-	return p.peerConn.persistent
-}
-
-// NodeInfo returns a copy of the peer's NodeInfo.
-func (p *peer) NodeInfo() types.NodeInfo {
-	return p.nodeInfo
-}
-
-// SocketAddr returns the address of the socket.
-// For outbound peers, it's the address dialed (after DNS resolution).
-// For inbound peers, it's the address returned by the underlying connection
-// (not what's reported in the peer's NodeInfo).
-func (p *peer) SocketAddr() *NetAddress {
-	endpoint := p.peerConn.conn.RemoteEndpoint()
-	return &NetAddress{
-		ID:   p.ID(),
-		IP:   endpoint.IP,
-		Port: endpoint.Port,
-	}
-}
-
-// Status returns the peer's ConnectionStatus.
-func (p *peer) Status() tmconn.ConnectionStatus {
-	return p.conn.Status()
-}
-
-// Send msg bytes to the channel identified by chID byte. Returns false if the
-// send queue is full after timeout, specified by MConnection.
-func (p *peer) Send(chID byte, msgBytes []byte) bool {
-	if !p.IsRunning() {
-		// see Switch#Broadcast, where we fetch the list of peers and loop over
-		// them - while we're looping, one peer may be removed and stopped.
-		return false
-	} else if !p.hasChannel(chID) {
-		return false
-	}
-	res, err := p.conn.SendMessage(ChannelID(chID), msgBytes)
-	if err == io.EOF {
-		return false
-	} else if err != nil {
-		p.onError(err)
-		return false
-	}
-	if res {
-		labels := []string{
-			"peer_id", string(p.ID()),
-			"chID", fmt.Sprintf("%#x", chID),
-		}
-		p.metrics.PeerSendBytesTotal.With(labels...).Add(float64(len(msgBytes)))
-	}
-	return res
-}
-
-// TrySend msg bytes to the channel identified by chID byte. Immediately returns
-// false if the send queue is full.
-func (p *peer) TrySend(chID byte, msgBytes []byte) bool {
-	if !p.IsRunning() {
-		return false
-	} else if !p.hasChannel(chID) {
-		return false
-	}
-	res, err := p.conn.TrySendMessage(ChannelID(chID), msgBytes)
-	if err == io.EOF {
-		return false
-	} else if err != nil {
-		p.onError(err)
-		return false
-	}
-	if res {
-		labels := []string{
-			"peer_id", string(p.ID()),
-			"chID", fmt.Sprintf("%#x", chID),
-		}
-		p.metrics.PeerSendBytesTotal.With(labels...).Add(float64(len(msgBytes)))
-	}
-	return res
-}
-
-// Get the data for a given key.
-func (p *peer) Get(key string) interface{} {
-	return p.Data.Get(key)
-}
-
-// Set sets the data for the given key.
-func (p *peer) Set(key string, data interface{}) {
-	p.Data.Set(key, data)
-}
-
-// hasChannel returns true if the peer reported
-// knowing about the given chID.
-func (p *peer) hasChannel(chID byte) bool {
-	for _, ch := range p.channels {
-		if ch == chID {
-			return true
-		}
-	}
-	// NOTE: probably will want to remove this
-	// but could be helpful while the feature is new
-	p.Logger.Debug(
-		"Unknown channel for peer",
-		"channel",
-		chID,
-		"channels",
-		p.channels,
-	)
-	return false
-}
-
-// CloseConn closes original connection. Used for cleaning up in cases where the peer had not been started at all.
-func (p *peer) CloseConn() error {
-	return p.peerConn.conn.Close()
-}
-
-//---------------------------------------------------
-// methods only used for testing
-// TODO: can we remove these?
-
-// CloseConn closes the underlying connection
-func (pc *peerConn) CloseConn() {
-	pc.conn.Close()
-}
-
-// RemoteAddr returns peer's remote network address.
-func (p *peer) RemoteAddr() net.Addr {
-	endpoint := p.conn.RemoteEndpoint()
-	return &net.TCPAddr{
-		IP:   endpoint.IP,
-		Port: int(endpoint.Port),
-	}
-}
-
-//---------------------------------------------------
-
-func PeerMetrics(metrics *Metrics) PeerOption {
-	return func(p *peer) {
-		p.metrics = metrics
-	}
-}
-
-func (p *peer) metricsReporter() {
-	for {
-		select {
-		case <-p.metricsTicker.C:
-			status := p.conn.Status()
-			var sendQueueSize float64
-			for _, chStatus := range status.Channels {
-				sendQueueSize += float64(chStatus.SendQueueSize)
-			}
-
-			p.metrics.PeerPendingSendBytes.With("peer_id", string(p.ID())).Set(sendQueueSize)
-		case <-p.Quit():
-			return
-		}
-	}
-}
diff --git a/internal/p2p/peer_set.go b/internal/p2p/peer_set.go
deleted file mode 100644
index 8d4ad4939e..0000000000
--- a/internal/p2p/peer_set.go
+++ /dev/null
@@ -1,149 +0,0 @@
-package p2p
-
-import (
-	"net"
-
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/types"
-)
-
-// IPeerSet has a (immutable) subset of the methods of PeerSet.
-type IPeerSet interface {
-	Has(key types.NodeID) bool
-	HasIP(ip net.IP) bool
-	Get(key types.NodeID) Peer
-	List() []Peer
-	Size() int
-}
-
-//-----------------------------------------------------------------------------
-
-// PeerSet is a special structure for keeping a table of peers.
-// Iteration over the peers is super fast and thread-safe.
-type PeerSet struct {
-	mtx    tmsync.Mutex
-	lookup map[types.NodeID]*peerSetItem
-	list   []Peer
-}
-
-type peerSetItem struct {
-	peer  Peer
-	index int
-}
-
-// NewPeerSet creates a new peerSet with a list of initial capacity of 256 items.
-func NewPeerSet() *PeerSet {
-	return &PeerSet{
-		lookup: make(map[types.NodeID]*peerSetItem),
-		list:   make([]Peer, 0, 256),
-	}
-}
-
-// Add adds the peer to the PeerSet.
-// It returns an error carrying the reason, if the peer is already present.
-func (ps *PeerSet) Add(peer Peer) error {
-	ps.mtx.Lock()
-	defer ps.mtx.Unlock()
-
-	if ps.lookup[peer.ID()] != nil {
-		return ErrSwitchDuplicatePeerID{peer.ID()}
-	}
-
-	index := len(ps.list)
-	// Appending is safe even with other goroutines
-	// iterating over the ps.list slice.
-	ps.list = append(ps.list, peer)
-	ps.lookup[peer.ID()] = &peerSetItem{peer, index}
-	return nil
-}
-
-// Has returns true if the set contains the peer referred to by this
-// peerKey, otherwise false.
-func (ps *PeerSet) Has(peerKey types.NodeID) bool {
-	ps.mtx.Lock()
-	_, ok := ps.lookup[peerKey]
-	ps.mtx.Unlock()
-	return ok
-}
-
-// HasIP returns true if the set contains the peer referred to by this IP
-// address, otherwise false.
-func (ps *PeerSet) HasIP(peerIP net.IP) bool {
-	ps.mtx.Lock()
-	defer ps.mtx.Unlock()
-
-	return ps.hasIP(peerIP)
-}
-
-// hasIP does not acquire a lock so it can be used in public methods which
-// already lock.
-func (ps *PeerSet) hasIP(peerIP net.IP) bool {
-	for _, item := range ps.lookup {
-		if item.peer.RemoteIP().Equal(peerIP) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// Get looks up a peer by the provided peerKey. Returns nil if peer is not
-// found.
-func (ps *PeerSet) Get(peerKey types.NodeID) Peer {
-	ps.mtx.Lock()
-	defer ps.mtx.Unlock()
-	item, ok := ps.lookup[peerKey]
-	if ok {
-		return item.peer
-	}
-	return nil
-}
-
-// Remove discards peer by its Key, if the peer was previously memoized.
-// Returns true if the peer was removed, and false if it was not found.
-// in the set.
-func (ps *PeerSet) Remove(peer Peer) bool {
-	ps.mtx.Lock()
-	defer ps.mtx.Unlock()
-
-	item := ps.lookup[peer.ID()]
-	if item == nil {
-		return false
-	}
-
-	index := item.index
-	// Create a new copy of the list but with one less item.
-	// (we must copy because we'll be mutating the list).
-	newList := make([]Peer, len(ps.list)-1)
-	copy(newList, ps.list)
-	// If it's the last peer, that's an easy special case.
-	if index == len(ps.list)-1 {
-		ps.list = newList
-		delete(ps.lookup, peer.ID())
-		return true
-	}
-
-	// Replace the popped item with the last item in the old list.
-	lastPeer := ps.list[len(ps.list)-1]
-	lastPeerKey := lastPeer.ID()
-	lastPeerItem := ps.lookup[lastPeerKey]
-	newList[index] = lastPeer
-	lastPeerItem.index = index
-	ps.list = newList
-	delete(ps.lookup, peer.ID())
-	return true
-}
-
-// Size returns the number of unique items in the peerSet.
-func (ps *PeerSet) Size() int {
-	ps.mtx.Lock()
-	defer ps.mtx.Unlock()
-	return len(ps.list)
-}
-
-// List returns the threadsafe list of peers.
-func (ps *PeerSet) List() []Peer {
-	ps.mtx.Lock()
-	defer ps.mtx.Unlock()
-	return ps.list
-}
diff --git a/internal/p2p/peer_set_test.go b/internal/p2p/peer_set_test.go
deleted file mode 100644
index 3e2397d2d0..0000000000
--- a/internal/p2p/peer_set_test.go
+++ /dev/null
@@ -1,190 +0,0 @@
-package p2p
-
-import (
-	"net"
-	"sync"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/tendermint/tendermint/libs/service"
-	"github.com/tendermint/tendermint/types"
-)
-
-// mockPeer for testing the PeerSet
-type mockPeer struct {
-	service.BaseService
-	ip net.IP
-	id types.NodeID
-}
-
-func (mp *mockPeer) FlushStop()                              { mp.Stop() } //nolint:errcheck // ignore error
-func (mp *mockPeer) TrySend(chID byte, msgBytes []byte) bool { return true }
-func (mp *mockPeer) Send(chID byte, msgBytes []byte) bool    { return true }
-func (mp *mockPeer) NodeInfo() types.NodeInfo                { return types.NodeInfo{} }
-func (mp *mockPeer) Status() ConnectionStatus                { return ConnectionStatus{} }
-func (mp *mockPeer) ID() types.NodeID                        { return mp.id }
-func (mp *mockPeer) IsOutbound() bool                        { return false }
-func (mp *mockPeer) IsPersistent() bool                      { return true }
-func (mp *mockPeer) Get(s string) interface{}                { return s }
-func (mp *mockPeer) Set(string, interface{})                 {}
-func (mp *mockPeer) RemoteIP() net.IP                        { return mp.ip }
-func (mp *mockPeer) SocketAddr() *NetAddress                 { return nil }
-func (mp *mockPeer) RemoteAddr() net.Addr                    { return &net.TCPAddr{IP: mp.ip, Port: 8800} }
-func (mp *mockPeer) CloseConn() error                        { return nil }
-
-// Returns a mock peer
-func newMockPeer(ip net.IP) *mockPeer {
-	if ip == nil {
-		ip = net.IP{127, 0, 0, 1}
-	}
-	nodeKey := types.GenNodeKey()
-	return &mockPeer{
-		ip: ip,
-		id: nodeKey.ID,
-	}
-}
-
-func TestPeerSetAddRemoveOne(t *testing.T) {
-	t.Parallel()
-
-	peerSet := NewPeerSet()
-
-	var peerList []Peer
-	for i := 0; i < 5; i++ {
-		p := newMockPeer(net.IP{127, 0, 0, byte(i)})
-		if err := peerSet.Add(p); err != nil {
-			t.Error(err)
-		}
-		peerList = append(peerList, p)
-	}
-
-	n := len(peerList)
-	// 1. Test removing from the front
-	for i, peerAtFront := range peerList {
-		removed := peerSet.Remove(peerAtFront)
-		assert.True(t, removed)
-		wantSize := n - i - 1
-		for j := 0; j < 2; j++ {
-			assert.Equal(t, false, peerSet.Has(peerAtFront.ID()), "#%d Run #%d: failed to remove peer", i, j)
-			assert.Equal(t, wantSize, peerSet.Size(), "#%d Run #%d: failed to remove peer and decrement size", i, j)
-			// Test the route of removing the now non-existent element
-			removed := peerSet.Remove(peerAtFront)
-			assert.False(t, removed)
-		}
-	}
-
-	// 2. Next we are testing removing the peer at the end
-	// a) Replenish the peerSet
-	for _, peer := range peerList {
-		if err := peerSet.Add(peer); err != nil {
-			t.Error(err)
-		}
-	}
-
-	// b) In reverse, remove each element
-	for i := n - 1; i >= 0; i-- {
-		peerAtEnd := peerList[i]
-		removed := peerSet.Remove(peerAtEnd)
-		assert.True(t, removed)
-		assert.Equal(t, false, peerSet.Has(peerAtEnd.ID()), "#%d: failed to remove item at end", i)
-		assert.Equal(t, i, peerSet.Size(), "#%d: differing sizes after peerSet.Remove(atEndPeer)", i)
-	}
-}
-
-func TestPeerSetAddRemoveMany(t *testing.T) {
-	t.Parallel()
-	peerSet := NewPeerSet()
-
-	peers := []Peer{}
-	N := 100
-	for i := 0; i < N; i++ {
-		peer := newMockPeer(net.IP{127, 0, 0, byte(i)})
-		if err := peerSet.Add(peer); err != nil {
-			t.Errorf("failed to add new peer")
-		}
-		if peerSet.Size() != i+1 {
-			t.Errorf("failed to add new peer and increment size")
-		}
-		peers = append(peers, peer)
-	}
-
-	for i, peer := range peers {
-		removed := peerSet.Remove(peer)
-		assert.True(t, removed)
-		if peerSet.Has(peer.ID()) {
-			t.Errorf("failed to remove peer")
-		}
-		if peerSet.Size() != len(peers)-i-1 {
-			t.Errorf("failed to remove peer and decrement size")
-		}
-	}
-}
-
-func TestPeerSetAddDuplicate(t *testing.T) {
-	t.Parallel()
-	peerSet := NewPeerSet()
-	peer := newMockPeer(nil)
-
-	n := 20
-	errsChan := make(chan error)
-	// Add the same asynchronously to test the
-	// concurrent guarantees of our APIs, and
-	// our expectation in the end is that only
-	// one addition succeeded, but the rest are
-	// instances of ErrSwitchDuplicatePeer.
-	for i := 0; i < n; i++ {
-		go func() {
-			errsChan <- peerSet.Add(peer)
-		}()
-	}
-
-	// Now collect and tally the results
-	errsTally := make(map[string]int)
-	for i := 0; i < n; i++ {
-		err := <-errsChan
-
-		switch err.(type) {
-		case ErrSwitchDuplicatePeerID:
-			errsTally["duplicateID"]++
-		default:
-			errsTally["other"]++
-		}
-	}
-
-	// Our next procedure is to ensure that only one addition
-	// succeeded and that the rest are each ErrSwitchDuplicatePeer.
-	wantErrCount, gotErrCount := n-1, errsTally["duplicateID"]
-	assert.Equal(t, wantErrCount, gotErrCount, "invalid ErrSwitchDuplicatePeer count")
-
-	wantNilErrCount, gotNilErrCount := 1, errsTally["other"]
-	assert.Equal(t, wantNilErrCount, gotNilErrCount, "invalid nil errCount")
-}
-
-func TestPeerSetGet(t *testing.T) {
-	t.Parallel()
-
-	var (
-		peerSet = NewPeerSet()
-		peer    = newMockPeer(nil)
-	)
-
-	assert.Nil(t, peerSet.Get(peer.ID()), "expecting a nil lookup, before .Add")
-
-	if err := peerSet.Add(peer); err != nil {
-		t.Fatalf("Failed to add new peer: %v", err)
-	}
-
-	var wg sync.WaitGroup
-	for i := 0; i < 10; i++ {
-		// Add them asynchronously to test the
-		// concurrent guarantees of our APIs.
-		wg.Add(1)
-		go func(i int) {
-			defer wg.Done()
-			have, want := peerSet.Get(peer.ID()), peer
-			assert.Equal(t, have, want, "%d: have %v, want %v", i, have, want)
-		}(i)
-	}
-	wg.Wait()
-}
diff --git a/internal/p2p/peer_test.go b/internal/p2p/peer_test.go
deleted file mode 100644
index dfe7bc798b..0000000000
--- a/internal/p2p/peer_test.go
+++ /dev/null
@@ -1,239 +0,0 @@
-package p2p
-
-import (
-	"context"
-	"fmt"
-	golog "log"
-	"net"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	"github.com/tendermint/tendermint/libs/bytes"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/types"
-
-	"github.com/tendermint/tendermint/config"
-	tmconn "github.com/tendermint/tendermint/internal/p2p/conn"
-)
-
-func TestPeerBasic(t *testing.T) {
-	assert, require := assert.New(t), require.New(t)
-
-	// simulate remote peer
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	t.Cleanup(rp.Stop)
-
-	p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), cfg, tmconn.DefaultMConnConfig())
-	require.Nil(err)
-
-	err = p.Start()
-	require.Nil(err)
-	t.Cleanup(func() {
-		if err := p.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	assert.True(p.IsRunning())
-	assert.True(p.IsOutbound())
-	assert.False(p.IsPersistent())
-	p.persistent = true
-	assert.True(p.IsPersistent())
-	assert.Equal(rp.Addr().DialString(), p.RemoteAddr().String())
-	assert.Equal(rp.ID(), p.ID())
-}
-
-func TestPeerSend(t *testing.T) {
-	assert, require := assert.New(t), require.New(t)
-
-	config := cfg
-
-	// simulate remote peer
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: config}
-	rp.Start()
-	t.Cleanup(rp.Stop)
-
-	p, err := createOutboundPeerAndPerformHandshake(rp.Addr(), config, tmconn.DefaultMConnConfig())
-	require.Nil(err)
-
-	err = p.Start()
-	require.Nil(err)
-
-	t.Cleanup(func() {
-		if err := p.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	assert.True(p.Send(testCh, []byte("Asylum")))
-}
-
-func createOutboundPeerAndPerformHandshake(
-	addr *NetAddress,
-	config *config.P2PConfig,
-	mConfig tmconn.MConnConfig,
-) (*peer, error) {
-	chDescs := []*tmconn.ChannelDescriptor{
-		{ID: testCh, Priority: 1},
-	}
-	pk := ed25519.GenPrivKey()
-	ourNodeInfo := testNodeInfo(types.NodeIDFromPubKey(pk.PubKey()), "host_peer")
-	transport := NewMConnTransport(log.TestingLogger(), mConfig, chDescs, MConnTransportOptions{})
-	reactorsByCh := map[byte]Reactor{testCh: NewTestReactor(chDescs, true)}
-	pc, err := testOutboundPeerConn(transport, addr, config, false, pk)
-	if err != nil {
-		return nil, err
-	}
-	peerInfo, _, err := pc.conn.Handshake(context.Background(), ourNodeInfo, pk)
-	if err != nil {
-		return nil, err
-	}
-
-	p := newPeer(peerInfo, pc, reactorsByCh, func(p Peer, r interface{}) {})
-	p.SetLogger(log.TestingLogger().With("peer", addr))
-	return p, nil
-}
-
-func testDial(addr *NetAddress, cfg *config.P2PConfig) (net.Conn, error) {
-	if cfg.TestDialFail {
-		return nil, fmt.Errorf("dial err (peerConfig.DialFail == true)")
-	}
-
-	conn, err := addr.DialTimeout(cfg.DialTimeout)
-	if err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
-func testOutboundPeerConn(
-	transport *MConnTransport,
-	addr *NetAddress,
-	config *config.P2PConfig,
-	persistent bool,
-	ourNodePrivKey crypto.PrivKey,
-) (peerConn, error) {
-
-	var pc peerConn
-	conn, err := testDial(addr, config)
-	if err != nil {
-		return pc, fmt.Errorf("error creating peer: %w", err)
-	}
-
-	pc, err = testPeerConn(transport, conn, true, persistent)
-	if err != nil {
-		if cerr := conn.Close(); cerr != nil {
-			return pc, fmt.Errorf("%v: %w", cerr.Error(), err)
-		}
-		return pc, err
-	}
-
-	return pc, nil
-}
-
-type remotePeer struct {
-	PrivKey    crypto.PrivKey
-	Config     *config.P2PConfig
-	Network    string
-	addr       *NetAddress
-	channels   bytes.HexBytes
-	listenAddr string
-	listener   net.Listener
-}
-
-func (rp *remotePeer) Addr() *NetAddress {
-	return rp.addr
-}
-
-func (rp *remotePeer) ID() types.NodeID {
-	return types.NodeIDFromPubKey(rp.PrivKey.PubKey())
-}
-
-func (rp *remotePeer) Start() {
-	if rp.listenAddr == "" {
-		rp.listenAddr = "127.0.0.1:0"
-	}
-
-	l, e := net.Listen("tcp", rp.listenAddr) // any available address
-	if e != nil {
-		golog.Fatalf("net.Listen tcp :0: %+v", e)
-	}
-	rp.listener = l
-	rp.addr = types.NewNetAddress(types.NodeIDFromPubKey(rp.PrivKey.PubKey()), l.Addr())
-	if rp.channels == nil {
-		rp.channels = []byte{testCh}
-	}
-	go rp.accept()
-}
-
-func (rp *remotePeer) Stop() {
-	rp.listener.Close()
-}
-
-func (rp *remotePeer) Dial(addr *NetAddress) (net.Conn, error) {
-	transport := NewMConnTransport(log.TestingLogger(), MConnConfig(rp.Config),
-		[]*ChannelDescriptor{}, MConnTransportOptions{})
-	conn, err := addr.DialTimeout(1 * time.Second)
-	if err != nil {
-		return nil, err
-	}
-	pc, err := testInboundPeerConn(transport, conn)
-	if err != nil {
-		return nil, err
-	}
-	_, _, err = pc.conn.Handshake(context.Background(), rp.nodeInfo(), rp.PrivKey)
-	if err != nil {
-		return nil, err
-	}
-	return conn, err
-}
-
-func (rp *remotePeer) accept() {
-	transport := NewMConnTransport(log.TestingLogger(), MConnConfig(rp.Config),
-		[]*ChannelDescriptor{}, MConnTransportOptions{})
-	conns := []net.Conn{}
-
-	for {
-		conn, err := rp.listener.Accept()
-		if err != nil {
-			golog.Printf("Failed to accept conn: %+v", err)
-			for _, conn := range conns {
-				_ = conn.Close()
-			}
-			return
-		}
-
-		pc, err := testInboundPeerConn(transport, conn)
-		if err != nil {
-			golog.Printf("Failed to create a peer: %+v", err)
-		}
-		_, _, err = pc.conn.Handshake(context.Background(), rp.nodeInfo(), rp.PrivKey)
-		if err != nil {
-			golog.Printf("Failed to handshake a peer: %+v", err)
-		}
-
-		conns = append(conns, conn)
-	}
-}
-
-func (rp *remotePeer) nodeInfo() types.NodeInfo {
-	ni := types.NodeInfo{
-		ProtocolVersion: defaultProtocolVersion,
-		NodeID:          rp.Addr().ID,
-		ListenAddr:      rp.listener.Addr().String(),
-		Network:         "testing",
-		Version:         "1.2.3-rc0-deadbeef",
-		Channels:        rp.channels,
-		Moniker:         "remote_peer",
-	}
-	if rp.Network != "" {
-		ni.Network = rp.Network
-	}
-	return ni
-}
diff --git a/internal/p2p/pex/addrbook.go b/internal/p2p/pex/addrbook.go
deleted file mode 100644
index 6c5f786637..0000000000
--- a/internal/p2p/pex/addrbook.go
+++ /dev/null
@@ -1,948 +0,0 @@
-// Modified for Tendermint
-// Originally Copyright (c) 2013-2014 Conformal Systems LLC.
-// https://github.com/conformal/btcd/blob/master/LICENSE
-
-package pex
-
-import (
-	"encoding/binary"
-	"fmt"
-	"hash"
-	"math"
-	mrand "math/rand"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/minio/highwayhash"
-	"github.com/tendermint/tendermint/crypto"
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/p2p"
-	tmmath "github.com/tendermint/tendermint/libs/math"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
-	"github.com/tendermint/tendermint/libs/service"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	bucketTypeNew = 0x01
-	bucketTypeOld = 0x02
-)
-
-// AddrBook is an address book used for tracking peers
-// so we can gossip about them to others and select
-// peers to dial.
-// TODO: break this up?
-type AddrBook interface {
-	service.Service
-
-	// Add our own addresses so we don't later add ourselves
-	AddOurAddress(*p2p.NetAddress)
-	// Check if it is our address
-	OurAddress(*p2p.NetAddress) bool
-
-	AddPrivateIDs([]string)
-
-	// Add and remove an address
-	AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error
-	RemoveAddress(*p2p.NetAddress)
-
-	// Check if the address is in the book
-	HasAddress(*p2p.NetAddress) bool
-
-	// Do we need more peers?
-	NeedMoreAddrs() bool
-	// Is Address Book Empty? Answer should not depend on being in your own
-	// address book, or private peers
-	Empty() bool
-
-	// Pick an address to dial
-	PickAddress(biasTowardsNewAddrs int) *p2p.NetAddress
-
-	// Mark address
-	MarkGood(types.NodeID)
-	MarkAttempt(*p2p.NetAddress)
-	MarkBad(*p2p.NetAddress, time.Duration) // Move peer to bad peers list
-	// Add bad peers back to addrBook
-	ReinstateBadPeers()
-
-	IsGood(*p2p.NetAddress) bool
-	IsBanned(*p2p.NetAddress) bool
-
-	// Send a selection of addresses to peers
-	GetSelection() []*p2p.NetAddress
-	// Send a selection of addresses with bias
-	GetSelectionWithBias(biasTowardsNewAddrs int) []*p2p.NetAddress
-
-	Size() int
-
-	// Persist to disk
-	Save()
-}
-
-var _ AddrBook = (*addrBook)(nil)
-
-// addrBook - concurrency safe peer address manager.
-// Implements AddrBook.
-type addrBook struct {
-	service.BaseService
-
-	// accessed concurrently
-	mtx        tmsync.Mutex
-	ourAddrs   map[string]struct{}
-	privateIDs map[types.NodeID]struct{}
-	addrLookup map[types.NodeID]*knownAddress // new & old
-	badPeers   map[types.NodeID]*knownAddress // blacklisted peers
-	bucketsOld []map[string]*knownAddress
-	bucketsNew []map[string]*knownAddress
-	nOld       int
-	nNew       int
-
-	// immutable after creation
-	filePath          string
-	key               string // random prefix for bucket placement
-	routabilityStrict bool
-	hasher            hash.Hash64
-
-	wg sync.WaitGroup
-}
-
-func mustNewHasher() hash.Hash64 {
-	key := crypto.CRandBytes(highwayhash.Size)
-	hasher, err := highwayhash.New64(key)
-	if err != nil {
-		panic(err)
-	}
-	return hasher
-}
-
-// NewAddrBook creates a new address book.
-// Use Start to begin processing asynchronous address updates.
-func NewAddrBook(filePath string, routabilityStrict bool) AddrBook {
-	am := &addrBook{
-		ourAddrs:          make(map[string]struct{}),
-		privateIDs:        make(map[types.NodeID]struct{}),
-		addrLookup:        make(map[types.NodeID]*knownAddress),
-		badPeers:          make(map[types.NodeID]*knownAddress),
-		filePath:          filePath,
-		routabilityStrict: routabilityStrict,
-	}
-	am.init()
-	am.BaseService = *service.NewBaseService(nil, "AddrBook", am)
-	return am
-}
-
-// Initialize the buckets.
-// When modifying this, don't forget to update loadFromFile()
-func (a *addrBook) init() {
-	a.key = crypto.CRandHex(24) // 24/2 * 8 = 96 bits
-	// New addr buckets
-	a.bucketsNew = make([]map[string]*knownAddress, newBucketCount)
-	for i := range a.bucketsNew {
-		a.bucketsNew[i] = make(map[string]*knownAddress)
-	}
-	// Old addr buckets
-	a.bucketsOld = make([]map[string]*knownAddress, oldBucketCount)
-	for i := range a.bucketsOld {
-		a.bucketsOld[i] = make(map[string]*knownAddress)
-	}
-	a.hasher = mustNewHasher()
-}
-
-// OnStart implements Service.
-func (a *addrBook) OnStart() error {
-	if err := a.BaseService.OnStart(); err != nil {
-		return err
-	}
-	a.loadFromFile(a.filePath)
-
-	// wg.Add to ensure that any invocation of .Wait()
-	// later on will wait for saveRoutine to terminate.
-	a.wg.Add(1)
-	go a.saveRoutine()
-
-	return nil
-}
-
-// OnStop implements Service.
-func (a *addrBook) OnStop() {
-	a.BaseService.OnStop()
-}
-
-func (a *addrBook) Wait() {
-	a.wg.Wait()
-}
-
-func (a *addrBook) FilePath() string {
-	return a.filePath
-}
-
-//-------------------------------------------------------
-
-// AddOurAddress one of our addresses.
-func (a *addrBook) AddOurAddress(addr *p2p.NetAddress) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	a.Logger.Info("Add our address to book", "addr", addr)
-	a.ourAddrs[addr.String()] = struct{}{}
-}
-
-// OurAddress returns true if it is our address.
-func (a *addrBook) OurAddress(addr *p2p.NetAddress) bool {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	_, ok := a.ourAddrs[addr.String()]
-	return ok
-}
-
-func (a *addrBook) AddPrivateIDs(ids []string) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	for _, id := range ids {
-		a.privateIDs[types.NodeID(id)] = struct{}{}
-	}
-}
-
-// AddAddress implements AddrBook
-// Add address to a "new" bucket. If it's already in one, only add it probabilistically.
-// Returns error if the addr is non-routable. Does not add self.
-// NOTE: addr must not be nil
-func (a *addrBook) AddAddress(addr *p2p.NetAddress, src *p2p.NetAddress) error {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	return a.addAddress(addr, src)
-}
-
-// RemoveAddress implements AddrBook - removes the address from the book.
-func (a *addrBook) RemoveAddress(addr *p2p.NetAddress) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	a.removeAddress(addr)
-}
-
-// IsGood returns true if peer was ever marked as good and haven't
-// done anything wrong since then.
-func (a *addrBook) IsGood(addr *p2p.NetAddress) bool {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	return a.addrLookup[addr.ID].isOld()
-}
-
-// IsBanned returns true if the peer is currently banned
-func (a *addrBook) IsBanned(addr *p2p.NetAddress) bool {
-	a.mtx.Lock()
-	_, ok := a.badPeers[addr.ID]
-	a.mtx.Unlock()
-
-	return ok
-}
-
-// HasAddress returns true if the address is in the book.
-func (a *addrBook) HasAddress(addr *p2p.NetAddress) bool {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	ka := a.addrLookup[addr.ID]
-	return ka != nil
-}
-
-// NeedMoreAddrs implements AddrBook - returns true if there are not have enough addresses in the book.
-func (a *addrBook) NeedMoreAddrs() bool {
-	return a.Size() < needAddressThreshold
-}
-
-// Empty implements AddrBook - returns true if there are no addresses in the address book.
-// Does not count the peer appearing in its own address book, or private peers.
-func (a *addrBook) Empty() bool {
-	return a.Size() == 0
-}
-
-// PickAddress implements AddrBook. It picks an address to connect to.
-// The address is picked randomly from an old or new bucket according
-// to the biasTowardsNewAddrs argument, which must be between [0, 100] (or else is truncated to that range)
-// and determines how biased we are to pick an address from a new bucket.
-// PickAddress returns nil if the AddrBook is empty or if we try to pick
-// from an empty bucket.
-// nolint:gosec // G404: Use of weak random number generator
-func (a *addrBook) PickAddress(biasTowardsNewAddrs int) *p2p.NetAddress {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	bookSize := a.size()
-	if bookSize <= 0 {
-		if bookSize < 0 {
-			panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
-		}
-		return nil
-	}
-	if biasTowardsNewAddrs > 100 {
-		biasTowardsNewAddrs = 100
-	}
-	if biasTowardsNewAddrs < 0 {
-		biasTowardsNewAddrs = 0
-	}
-
-	// Bias between new and old addresses.
-	oldCorrelation := math.Sqrt(float64(a.nOld)) * (100.0 - float64(biasTowardsNewAddrs))
-	newCorrelation := math.Sqrt(float64(a.nNew)) * float64(biasTowardsNewAddrs)
-
-	// pick a random peer from a random bucket
-	var bucket map[string]*knownAddress
-	pickFromOldBucket := (newCorrelation+oldCorrelation)*mrand.Float64() < oldCorrelation
-	if (pickFromOldBucket && a.nOld == 0) ||
-		(!pickFromOldBucket && a.nNew == 0) {
-		return nil
-	}
-	// loop until we pick a random non-empty bucket
-	for len(bucket) == 0 {
-		if pickFromOldBucket {
-			bucket = a.bucketsOld[mrand.Intn(len(a.bucketsOld))]
-		} else {
-			bucket = a.bucketsNew[mrand.Intn(len(a.bucketsNew))]
-		}
-	}
-	// pick a random index and loop over the map to return that index
-	randIndex := mrand.Intn(len(bucket))
-	for _, ka := range bucket {
-		if randIndex == 0 {
-			return ka.Addr
-		}
-		randIndex--
-	}
-	return nil
-}
-
-// MarkGood implements AddrBook - it marks the peer as good and
-// moves it into an "old" bucket.
-func (a *addrBook) MarkGood(id types.NodeID) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	ka := a.addrLookup[id]
-	if ka == nil {
-		return
-	}
-	ka.markGood()
-	if ka.isNew() {
-		if err := a.moveToOld(ka); err != nil {
-			a.Logger.Error("Error moving address to old", "err", err)
-		}
-	}
-}
-
-// MarkAttempt implements AddrBook - it marks that an attempt was made to connect to the address.
-func (a *addrBook) MarkAttempt(addr *p2p.NetAddress) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	ka := a.addrLookup[addr.ID]
-	if ka == nil {
-		return
-	}
-	ka.markAttempt()
-}
-
-// MarkBad implements AddrBook. Kicks address out from book, places
-// the address in the badPeers pool.
-func (a *addrBook) MarkBad(addr *p2p.NetAddress, banTime time.Duration) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	if a.addBadPeer(addr, banTime) {
-		a.removeAddress(addr)
-	}
-}
-
-// ReinstateBadPeers removes bad peers from ban list and places them into a new
-// bucket.
-func (a *addrBook) ReinstateBadPeers() {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	for _, ka := range a.badPeers {
-		if ka.isBanned() {
-			continue
-		}
-
-		bucket, err := a.calcNewBucket(ka.Addr, ka.Src)
-		if err != nil {
-			a.Logger.Error("Failed to calculate new bucket (bad peer won't be reinstantiated)",
-				"addr", ka.Addr, "err", err)
-			continue
-		}
-
-		if err := a.addToNewBucket(ka, bucket); err != nil {
-			a.Logger.Error("Error adding peer to new bucket", "err", err)
-		}
-		delete(a.badPeers, ka.ID())
-
-		a.Logger.Info("Reinstated address", "addr", ka.Addr)
-	}
-}
-
-// GetSelection implements AddrBook.
-// It randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
-// Must never return a nil address.
-func (a *addrBook) GetSelection() []*p2p.NetAddress {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	bookSize := a.size()
-	if bookSize <= 0 {
-		if bookSize < 0 {
-			panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
-		}
-		return nil
-	}
-
-	numAddresses := tmmath.MaxInt(
-		tmmath.MinInt(minGetSelection, bookSize),
-		bookSize*getSelectionPercent/100)
-	numAddresses = tmmath.MinInt(maxGetSelection, numAddresses)
-
-	// XXX: instead of making a list of all addresses, shuffling, and slicing a random chunk,
-	// could we just select a random numAddresses of indexes?
-	allAddr := make([]*p2p.NetAddress, bookSize)
-	i := 0
-	for _, ka := range a.addrLookup {
-		allAddr[i] = ka.Addr
-		i++
-	}
-
-	// Fisher-Yates shuffle the array. We only need to do the first
-	// `numAddresses' since we are throwing the rest.
-	for i := 0; i < numAddresses; i++ {
-		// pick a number between current index and the end
-		// nolint:gosec // G404: Use of weak random number generator
-		j := mrand.Intn(len(allAddr)-i) + i
-		allAddr[i], allAddr[j] = allAddr[j], allAddr[i]
-	}
-
-	// slice off the limit we are willing to share.
-	return allAddr[:numAddresses]
-}
-
-func percentageOfNum(p, n int) int {
-	return int(math.Round((float64(p) / float64(100)) * float64(n)))
-}
-
-// GetSelectionWithBias implements AddrBook.
-// It randomly selects some addresses (old & new). Suitable for peer-exchange protocols.
-// Must never return a nil address.
-//
-// Each address is picked randomly from an old or new bucket according to the
-// biasTowardsNewAddrs argument, which must be between [0, 100] (or else is truncated to
-// that range) and determines how biased we are to pick an address from a new
-// bucket.
-func (a *addrBook) GetSelectionWithBias(biasTowardsNewAddrs int) []*p2p.NetAddress {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	bookSize := a.size()
-	if bookSize <= 0 {
-		if bookSize < 0 {
-			panic(fmt.Sprintf("Addrbook size %d (new: %d + old: %d) is less than 0", a.nNew+a.nOld, a.nNew, a.nOld))
-		}
-		return nil
-	}
-
-	if biasTowardsNewAddrs > 100 {
-		biasTowardsNewAddrs = 100
-	}
-	if biasTowardsNewAddrs < 0 {
-		biasTowardsNewAddrs = 0
-	}
-
-	numAddresses := tmmath.MaxInt(
-		tmmath.MinInt(minGetSelection, bookSize),
-		bookSize*getSelectionPercent/100)
-	numAddresses = tmmath.MinInt(maxGetSelection, numAddresses)
-
-	// number of new addresses that, if possible, should be in the beginning of the selection
-	// if there are no enough old addrs, will choose new addr instead.
-	numRequiredNewAdd := tmmath.MaxInt(percentageOfNum(biasTowardsNewAddrs, numAddresses), numAddresses-a.nOld)
-	selection := a.randomPickAddresses(bucketTypeNew, numRequiredNewAdd)
-	selection = append(selection, a.randomPickAddresses(bucketTypeOld, numAddresses-len(selection))...)
-	return selection
-}
-
-//------------------------------------------------
-
-// Size returns the number of addresses in the book.
-func (a *addrBook) Size() int {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	return a.size()
-}
-
-func (a *addrBook) size() int {
-	return a.nNew + a.nOld
-}
-
-//----------------------------------------------------------
-
-// Save persists the address book to disk.
-func (a *addrBook) Save() {
-	a.saveToFile(a.filePath) // thread safe
-}
-
-func (a *addrBook) saveRoutine() {
-	defer a.wg.Done()
-
-	saveFileTicker := time.NewTicker(dumpAddressInterval)
-out:
-	for {
-		select {
-		case <-saveFileTicker.C:
-			a.saveToFile(a.filePath)
-		case <-a.Quit():
-			break out
-		}
-	}
-	saveFileTicker.Stop()
-	a.saveToFile(a.filePath)
-}
-
-//----------------------------------------------------------
-
-func (a *addrBook) getBucket(bucketType byte, bucketIdx int) map[string]*knownAddress {
-	switch bucketType {
-	case bucketTypeNew:
-		return a.bucketsNew[bucketIdx]
-	case bucketTypeOld:
-		return a.bucketsOld[bucketIdx]
-	default:
-		panic("Invalid bucket type")
-	}
-}
-
-// Adds ka to new bucket. Returns false if it couldn't do it cuz buckets full.
-// NOTE: currently it always returns true.
-func (a *addrBook) addToNewBucket(ka *knownAddress, bucketIdx int) error {
-	// Consistency check to ensure we don't add an already known address
-	if ka.isOld() {
-		return errAddrBookOldAddressNewBucket{ka.Addr, bucketIdx}
-	}
-
-	addrStr := ka.Addr.String()
-	bucket := a.getBucket(bucketTypeNew, bucketIdx)
-
-	// Already exists?
-	if _, ok := bucket[addrStr]; ok {
-		return nil
-	}
-
-	// Enforce max addresses.
-	if len(bucket) > newBucketSize {
-		a.Logger.Info("new bucket is full, expiring new")
-		a.expireNew(bucketIdx)
-	}
-
-	// Add to bucket.
-	bucket[addrStr] = ka
-	// increment nNew if the peer doesnt already exist in a bucket
-	if ka.addBucketRef(bucketIdx) == 1 {
-		a.nNew++
-	}
-
-	// Add it to addrLookup
-	a.addrLookup[ka.ID()] = ka
-	return nil
-}
-
-// Adds ka to old bucket. Returns false if it couldn't do it cuz buckets full.
-func (a *addrBook) addToOldBucket(ka *knownAddress, bucketIdx int) bool {
-	// Sanity check
-	if ka.isNew() {
-		a.Logger.Error(fmt.Sprintf("Cannot add new address to old bucket: %v", ka))
-		return false
-	}
-	if len(ka.Buckets) != 0 {
-		a.Logger.Error(fmt.Sprintf("Cannot add already old address to another old bucket: %v", ka))
-		return false
-	}
-
-	addrStr := ka.Addr.String()
-	bucket := a.getBucket(bucketTypeOld, bucketIdx)
-
-	// Already exists?
-	if _, ok := bucket[addrStr]; ok {
-		return true
-	}
-
-	// Enforce max addresses.
-	if len(bucket) > oldBucketSize {
-		return false
-	}
-
-	// Add to bucket.
-	bucket[addrStr] = ka
-	if ka.addBucketRef(bucketIdx) == 1 {
-		a.nOld++
-	}
-
-	// Ensure in addrLookup
-	a.addrLookup[ka.ID()] = ka
-
-	return true
-}
-
-func (a *addrBook) removeFromBucket(ka *knownAddress, bucketType byte, bucketIdx int) {
-	if ka.BucketType != bucketType {
-		a.Logger.Error(fmt.Sprintf("Bucket type mismatch: %v", ka))
-		return
-	}
-	bucket := a.getBucket(bucketType, bucketIdx)
-	delete(bucket, ka.Addr.String())
-	if ka.removeBucketRef(bucketIdx) == 0 {
-		if bucketType == bucketTypeNew {
-			a.nNew--
-		} else {
-			a.nOld--
-		}
-		delete(a.addrLookup, ka.ID())
-	}
-}
-
-func (a *addrBook) removeFromAllBuckets(ka *knownAddress) {
-	for _, bucketIdx := range ka.Buckets {
-		bucket := a.getBucket(ka.BucketType, bucketIdx)
-		delete(bucket, ka.Addr.String())
-	}
-	ka.Buckets = nil
-	if ka.BucketType == bucketTypeNew {
-		a.nNew--
-	} else {
-		a.nOld--
-	}
-	delete(a.addrLookup, ka.ID())
-}
-
-//----------------------------------------------------------
-
-func (a *addrBook) pickOldest(bucketType byte, bucketIdx int) *knownAddress {
-	bucket := a.getBucket(bucketType, bucketIdx)
-	var oldest *knownAddress
-	for _, ka := range bucket {
-		if oldest == nil || ka.LastAttempt.Before(oldest.LastAttempt) {
-			oldest = ka
-		}
-	}
-	return oldest
-}
-
-// adds the address to a "new" bucket. if its already in one,
-// it only adds it probabilistically
-func (a *addrBook) addAddress(addr, src *p2p.NetAddress) error {
-	if addr == nil || src == nil {
-		return ErrAddrBookNilAddr{addr, src}
-	}
-
-	if err := addr.Valid(); err != nil {
-		return ErrAddrBookInvalidAddr{Addr: addr, AddrErr: err}
-	}
-
-	if _, ok := a.badPeers[addr.ID]; ok {
-		return ErrAddressBanned{addr}
-	}
-
-	if _, ok := a.privateIDs[addr.ID]; ok {
-		return ErrAddrBookPrivate{addr}
-	}
-
-	if _, ok := a.privateIDs[src.ID]; ok {
-		return ErrAddrBookPrivateSrc{src}
-	}
-
-	// TODO: we should track ourAddrs by ID and by IP:PORT and refuse both.
-	if _, ok := a.ourAddrs[addr.String()]; ok {
-		return ErrAddrBookSelf{addr}
-	}
-
-	if a.routabilityStrict && !addr.Routable() {
-		return ErrAddrBookNonRoutable{addr}
-	}
-
-	ka := a.addrLookup[addr.ID]
-	if ka != nil {
-		// If its already old and the address ID's are the same, ignore it.
-		// Thereby avoiding issues with a node on the network attempting to change
-		// the IP of a known node ID. (Which could yield an eclipse attack on the node)
-		if ka.isOld() && ka.Addr.ID == addr.ID {
-			return nil
-		}
-		// Already in max new buckets.
-		if len(ka.Buckets) == maxNewBucketsPerAddress {
-			return nil
-		}
-		// The more entries we have, the less likely we are to add more.
-		factor := int32(2 * len(ka.Buckets))
-		// nolint:gosec // G404: Use of weak random number generator
-		if mrand.Int31n(factor) != 0 {
-			return nil
-		}
-	} else {
-		ka = newKnownAddress(addr, src)
-	}
-
-	bucket, err := a.calcNewBucket(addr, src)
-	if err != nil {
-		return err
-	}
-	return a.addToNewBucket(ka, bucket)
-}
-
-func (a *addrBook) randomPickAddresses(bucketType byte, num int) []*p2p.NetAddress {
-	var buckets []map[string]*knownAddress
-	switch bucketType {
-	case bucketTypeNew:
-		buckets = a.bucketsNew
-	case bucketTypeOld:
-		buckets = a.bucketsOld
-	default:
-		panic("unexpected bucketType")
-	}
-	total := 0
-	for _, bucket := range buckets {
-		total += len(bucket)
-	}
-	addresses := make([]*knownAddress, 0, total)
-	for _, bucket := range buckets {
-		for _, ka := range bucket {
-			addresses = append(addresses, ka)
-		}
-	}
-	selection := make([]*p2p.NetAddress, 0, num)
-	chosenSet := make(map[string]bool, num)
-	rand := tmrand.NewRand()
-	rand.Shuffle(total, func(i, j int) {
-		addresses[i], addresses[j] = addresses[j], addresses[i]
-	})
-	for _, addr := range addresses {
-		if chosenSet[addr.Addr.String()] {
-			continue
-		}
-		chosenSet[addr.Addr.String()] = true
-		selection = append(selection, addr.Addr)
-		if len(selection) >= num {
-			return selection
-		}
-	}
-	return selection
-}
-
-// Make space in the new buckets by expiring the really bad entries.
-// If no bad entries are available we remove the oldest.
-func (a *addrBook) expireNew(bucketIdx int) {
-	for addrStr, ka := range a.bucketsNew[bucketIdx] {
-		// If an entry is bad, throw it away
-		if ka.isBad() {
-			a.Logger.Info(fmt.Sprintf("expiring bad address %v", addrStr))
-			a.removeFromBucket(ka, bucketTypeNew, bucketIdx)
-			return
-		}
-	}
-
-	// If we haven't thrown out a bad entry, throw out the oldest entry
-	oldest := a.pickOldest(bucketTypeNew, bucketIdx)
-	a.removeFromBucket(oldest, bucketTypeNew, bucketIdx)
-}
-
-// Promotes an address from new to old. If the destination bucket is full,
-// demote the oldest one to a "new" bucket.
-// TODO: Demote more probabilistically?
-func (a *addrBook) moveToOld(ka *knownAddress) error {
-	// Sanity check
-	if ka.isOld() {
-		a.Logger.Error(fmt.Sprintf("Cannot promote address that is already old %v", ka))
-		return nil
-	}
-	if len(ka.Buckets) == 0 {
-		a.Logger.Error(fmt.Sprintf("Cannot promote address that isn't in any new buckets %v", ka))
-		return nil
-	}
-
-	// Remove from all (new) buckets.
-	a.removeFromAllBuckets(ka)
-	// It's officially old now.
-	ka.BucketType = bucketTypeOld
-
-	// Try to add it to its oldBucket destination.
-	oldBucketIdx, err := a.calcOldBucket(ka.Addr)
-	if err != nil {
-		return err
-	}
-	added := a.addToOldBucket(ka, oldBucketIdx)
-	if !added {
-		// No room; move the oldest to a new bucket
-		oldest := a.pickOldest(bucketTypeOld, oldBucketIdx)
-		a.removeFromBucket(oldest, bucketTypeOld, oldBucketIdx)
-		newBucketIdx, err := a.calcNewBucket(oldest.Addr, oldest.Src)
-		if err != nil {
-			return err
-		}
-		if err := a.addToNewBucket(oldest, newBucketIdx); err != nil {
-			a.Logger.Error("Error adding peer to old bucket", "err", err)
-		}
-
-		// Finally, add our ka to old bucket again.
-		added = a.addToOldBucket(ka, oldBucketIdx)
-		if !added {
-			a.Logger.Error(fmt.Sprintf("Could not re-add ka %v to oldBucketIdx %v", ka, oldBucketIdx))
-		}
-	}
-	return nil
-}
-
-func (a *addrBook) removeAddress(addr *p2p.NetAddress) {
-	ka := a.addrLookup[addr.ID]
-	if ka == nil {
-		return
-	}
-	a.Logger.Info("Remove address from book", "addr", addr)
-	a.removeFromAllBuckets(ka)
-}
-
-func (a *addrBook) addBadPeer(addr *p2p.NetAddress, banTime time.Duration) bool {
-	// check it exists in addrbook
-	ka := a.addrLookup[addr.ID]
-	// check address is not already there
-	if ka == nil {
-		return false
-	}
-
-	if _, alreadyBadPeer := a.badPeers[addr.ID]; !alreadyBadPeer {
-		// add to bad peer list
-		ka.ban(banTime)
-		a.badPeers[addr.ID] = ka
-		a.Logger.Info("Add address to blacklist", "addr", addr)
-	}
-	return true
-}
-
-//---------------------------------------------------------------------
-// calculate bucket placements
-
-// hash(key + sourcegroup + int64(hash(key + group + sourcegroup)) % bucket_per_group) % num_new_buckets
-func (a *addrBook) calcNewBucket(addr, src *p2p.NetAddress) (int, error) {
-	data1 := []byte{}
-	data1 = append(data1, []byte(a.key)...)
-	data1 = append(data1, []byte(a.groupKey(addr))...)
-	data1 = append(data1, []byte(a.groupKey(src))...)
-	hash1, err := a.hash(data1)
-	if err != nil {
-		return 0, err
-	}
-	hash64 := binary.BigEndian.Uint64(hash1)
-	hash64 %= newBucketsPerGroup
-	var hashbuf [8]byte
-	binary.BigEndian.PutUint64(hashbuf[:], hash64)
-	data2 := []byte{}
-	data2 = append(data2, []byte(a.key)...)
-	data2 = append(data2, a.groupKey(src)...)
-	data2 = append(data2, hashbuf[:]...)
-
-	hash2, err := a.hash(data2)
-	if err != nil {
-		return 0, err
-	}
-	result := int(binary.BigEndian.Uint64(hash2) % newBucketCount)
-	return result, nil
-}
-
-// hash(key + group + int64(hash(key + addr)) % buckets_per_group) % num_old_buckets
-func (a *addrBook) calcOldBucket(addr *p2p.NetAddress) (int, error) {
-	data1 := []byte{}
-	data1 = append(data1, []byte(a.key)...)
-	data1 = append(data1, []byte(addr.String())...)
-	hash1, err := a.hash(data1)
-	if err != nil {
-		return 0, err
-	}
-	hash64 := binary.BigEndian.Uint64(hash1)
-	hash64 %= oldBucketsPerGroup
-	var hashbuf [8]byte
-	binary.BigEndian.PutUint64(hashbuf[:], hash64)
-	data2 := []byte{}
-	data2 = append(data2, []byte(a.key)...)
-	data2 = append(data2, a.groupKey(addr)...)
-	data2 = append(data2, hashbuf[:]...)
-
-	hash2, err := a.hash(data2)
-	if err != nil {
-		return 0, err
-	}
-	result := int(binary.BigEndian.Uint64(hash2) % oldBucketCount)
-	return result, nil
-}
-
-// Return a string representing the network group of this address.
-// This is the /16 for IPv4 (e.g. 1.2.0.0), the /32 (/36 for he.net) for IPv6, the string
-// "local" for a local address and the string "unroutable" for an unroutable
-// address.
-func (a *addrBook) groupKey(na *p2p.NetAddress) string {
-	return groupKeyFor(na, a.routabilityStrict)
-}
-
-func groupKeyFor(na *p2p.NetAddress, routabilityStrict bool) string {
-	if routabilityStrict && na.Local() {
-		return "local"
-	}
-	if routabilityStrict && !na.Routable() {
-		return "unroutable"
-	}
-
-	if ipv4 := na.IP.To4(); ipv4 != nil {
-		return na.IP.Mask(net.CIDRMask(16, 32)).String()
-	}
-
-	if na.RFC6145() || na.RFC6052() {
-		// last four bytes are the ip address
-		ip := na.IP[12:16]
-		return ip.Mask(net.CIDRMask(16, 32)).String()
-	}
-
-	if na.RFC3964() {
-		ip := na.IP[2:6]
-		return ip.Mask(net.CIDRMask(16, 32)).String()
-	}
-
-	if na.RFC4380() {
-		// teredo tunnels have the last 4 bytes as the v4 address XOR
-		// 0xff.
-		ip := net.IP(make([]byte, 4))
-		for i, byte := range na.IP[12:16] {
-			ip[i] = byte ^ 0xff
-		}
-		return ip.Mask(net.CIDRMask(16, 32)).String()
-	}
-
-	if na.OnionCatTor() {
-		// group is keyed off the first 4 bits of the actual onion key.
-		return fmt.Sprintf("tor:%d", na.IP[6]&((1<<4)-1))
-	}
-
-	// OK, so now we know ourselves to be a IPv6 address.
-	// bitcoind uses /32 for everything, except for Hurricane Electric's
-	// (he.net) IP range, which it uses /36 for.
-	bits := 32
-	heNet := &net.IPNet{IP: net.ParseIP("2001:470::"), Mask: net.CIDRMask(32, 128)}
-	if heNet.Contains(na.IP) {
-		bits = 36
-	}
-	ipv6Mask := net.CIDRMask(bits, 128)
-	return na.IP.Mask(ipv6Mask).String()
-}
-
-func (a *addrBook) hash(b []byte) ([]byte, error) {
-	a.hasher.Reset()
-	a.hasher.Write(b)
-	return a.hasher.Sum(nil), nil
-}
diff --git a/internal/p2p/pex/addrbook_test.go b/internal/p2p/pex/addrbook_test.go
deleted file mode 100644
index 3d21314ad8..0000000000
--- a/internal/p2p/pex/addrbook_test.go
+++ /dev/null
@@ -1,777 +0,0 @@
-package pex
-
-import (
-	"encoding/hex"
-	"fmt"
-	"io/ioutil"
-	"math"
-	mrand "math/rand"
-	"net"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/libs/log"
-	tmmath "github.com/tendermint/tendermint/libs/math"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
-	"github.com/tendermint/tendermint/types"
-)
-
-// FIXME These tests should not rely on .(*addrBook) assertions
-
-func TestAddrBookPickAddress(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-
-	// 0 addresses
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	assert.Zero(t, book.Size())
-
-	addr := book.PickAddress(50)
-	assert.Nil(t, addr, "expected no address")
-
-	randAddrs := randNetAddressPairs(t, 1)
-	addrSrc := randAddrs[0]
-	err := book.AddAddress(addrSrc.addr, addrSrc.src)
-	require.NoError(t, err)
-
-	// pick an address when we only have new address
-	addr = book.PickAddress(0)
-	assert.NotNil(t, addr, "expected an address")
-	addr = book.PickAddress(50)
-	assert.NotNil(t, addr, "expected an address")
-	addr = book.PickAddress(100)
-	assert.NotNil(t, addr, "expected an address")
-
-	// pick an address when we only have old address
-	book.MarkGood(addrSrc.addr.ID)
-	addr = book.PickAddress(0)
-	assert.NotNil(t, addr, "expected an address")
-	addr = book.PickAddress(50)
-	assert.NotNil(t, addr, "expected an address")
-
-	// in this case, nNew==0 but we biased 100% to new, so we return nil
-	addr = book.PickAddress(100)
-	assert.Nil(t, addr, "did not expected an address")
-}
-
-func TestAddrBookSaveLoad(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-
-	// 0 addresses
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	book.Save()
-
-	book = NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	err := book.Start()
-	require.NoError(t, err)
-
-	assert.True(t, book.Empty())
-
-	// 100 addresses
-	randAddrs := randNetAddressPairs(t, 100)
-
-	for _, addrSrc := range randAddrs {
-		err := book.AddAddress(addrSrc.addr, addrSrc.src)
-		require.NoError(t, err)
-	}
-
-	assert.Equal(t, 100, book.Size())
-	book.Save()
-
-	book = NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	err = book.Start()
-	require.NoError(t, err)
-
-	assert.Equal(t, 100, book.Size())
-}
-
-func TestAddrBookLookup(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	randAddrs := randNetAddressPairs(t, 100)
-
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	for _, addrSrc := range randAddrs {
-		addr := addrSrc.addr
-		src := addrSrc.src
-		err := book.AddAddress(addr, src)
-		require.NoError(t, err)
-
-		ka := book.HasAddress(addr)
-		assert.True(t, ka, "Expected to find KnownAddress %v but wasn't there.", addr)
-	}
-}
-
-func TestAddrBookPromoteToOld(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	randAddrs := randNetAddressPairs(t, 100)
-
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	for _, addrSrc := range randAddrs {
-		err := book.AddAddress(addrSrc.addr, addrSrc.src)
-		require.NoError(t, err)
-	}
-
-	// Attempt all addresses.
-	for _, addrSrc := range randAddrs {
-		book.MarkAttempt(addrSrc.addr)
-	}
-
-	// Promote half of them
-	for i, addrSrc := range randAddrs {
-		if i%2 == 0 {
-			book.MarkGood(addrSrc.addr.ID)
-		}
-	}
-
-	// TODO: do more testing :)
-
-	selection := book.GetSelection()
-	t.Logf("selection: %v", selection)
-
-	if len(selection) > book.Size() {
-		t.Errorf("selection could not be bigger than the book")
-	}
-
-	selection = book.GetSelectionWithBias(30)
-	t.Logf("selection: %v", selection)
-
-	if len(selection) > book.Size() {
-		t.Errorf("selection with bias could not be bigger than the book")
-	}
-
-	assert.Equal(t, book.Size(), 100, "expecting book size to be 100")
-}
-
-func TestAddrBookHandlesDuplicates(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-
-	book.SetLogger(log.TestingLogger())
-
-	randAddrs := randNetAddressPairs(t, 100)
-
-	differentSrc := randIPv4Address(t)
-	for _, addrSrc := range randAddrs {
-		err := book.AddAddress(addrSrc.addr, addrSrc.src)
-		require.NoError(t, err)
-		err = book.AddAddress(addrSrc.addr, addrSrc.src) // duplicate
-		require.NoError(t, err)
-		err = book.AddAddress(addrSrc.addr, differentSrc) // different src
-		require.NoError(t, err)
-	}
-
-	assert.Equal(t, 100, book.Size())
-}
-
-type netAddressPair struct {
-	addr *p2p.NetAddress
-	src  *p2p.NetAddress
-}
-
-func randNetAddressPairs(t *testing.T, n int) []netAddressPair {
-	randAddrs := make([]netAddressPair, n)
-	for i := 0; i < n; i++ {
-		randAddrs[i] = netAddressPair{addr: randIPv4Address(t), src: randIPv4Address(t)}
-	}
-	return randAddrs
-}
-
-func randIPv4Address(t *testing.T) *p2p.NetAddress {
-	for {
-		ip := fmt.Sprintf("%v.%v.%v.%v",
-			mrand.Intn(254)+1,
-			mrand.Intn(255),
-			mrand.Intn(255),
-			mrand.Intn(255),
-		)
-		port := mrand.Intn(65535-1) + 1
-		id := types.NodeID(hex.EncodeToString(tmrand.Bytes(types.NodeIDByteLength)))
-		idAddr := id.AddressString(fmt.Sprintf("%v:%v", ip, port))
-		addr, err := types.NewNetAddressString(idAddr)
-		assert.Nil(t, err, "error generating rand network address")
-		if addr.Routable() {
-			return addr
-		}
-	}
-}
-
-func TestAddrBookRemoveAddress(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-
-	addr := randIPv4Address(t)
-	err := book.AddAddress(addr, addr)
-	require.NoError(t, err)
-	assert.Equal(t, 1, book.Size())
-
-	book.RemoveAddress(addr)
-	assert.Equal(t, 0, book.Size())
-
-	nonExistingAddr := randIPv4Address(t)
-	book.RemoveAddress(nonExistingAddr)
-	assert.Equal(t, 0, book.Size())
-}
-
-func TestAddrBookGetSelectionWithOneMarkedGood(t *testing.T) {
-	// create a book with 10 addresses, 1 good/old and 9 new
-	book, _ := createAddrBookWithMOldAndNNewAddrs(t, 1, 9)
-	addrs := book.GetSelectionWithBias(biasToSelectNewPeers)
-	assert.NotNil(t, addrs)
-	assertMOldAndNNewAddrsInSelection(t, 1, 9, addrs, book)
-}
-
-func TestAddrBookGetSelectionWithOneNotMarkedGood(t *testing.T) {
-	// create a book with 10 addresses, 9 good/old and 1 new
-	book, _ := createAddrBookWithMOldAndNNewAddrs(t, 9, 1)
-	addrs := book.GetSelectionWithBias(biasToSelectNewPeers)
-	assert.NotNil(t, addrs)
-	assertMOldAndNNewAddrsInSelection(t, 9, 1, addrs, book)
-}
-
-func TestAddrBookGetSelectionReturnsNilWhenAddrBookIsEmpty(t *testing.T) {
-	book, _ := createAddrBookWithMOldAndNNewAddrs(t, 0, 0)
-	addrs := book.GetSelectionWithBias(biasToSelectNewPeers)
-	assert.Nil(t, addrs)
-}
-
-func TestAddrBookGetSelection(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-
-	// 1) empty book
-	assert.Empty(t, book.GetSelection())
-
-	// 2) add one address
-	addr := randIPv4Address(t)
-	err := book.AddAddress(addr, addr)
-	require.NoError(t, err)
-
-	assert.Equal(t, 1, len(book.GetSelection()))
-	assert.Equal(t, addr, book.GetSelection()[0])
-
-	// 3) add a bunch of addresses
-	randAddrs := randNetAddressPairs(t, 100)
-	for _, addrSrc := range randAddrs {
-		err := book.AddAddress(addrSrc.addr, addrSrc.src)
-		require.NoError(t, err)
-	}
-
-	// check there is no duplicates
-	addrs := make(map[string]*p2p.NetAddress)
-	selection := book.GetSelection()
-	for _, addr := range selection {
-		if dup, ok := addrs[addr.String()]; ok {
-			t.Fatalf("selection %v contains duplicates %v", selection, dup)
-		}
-		addrs[addr.String()] = addr
-	}
-
-	if len(selection) > book.Size() {
-		t.Errorf("selection %v could not be bigger than the book", selection)
-	}
-}
-
-func TestAddrBookGetSelectionWithBias(t *testing.T) {
-	const biasTowardsNewAddrs = 30
-
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-
-	// 1) empty book
-	selection := book.GetSelectionWithBias(biasTowardsNewAddrs)
-	assert.Empty(t, selection)
-
-	// 2) add one address
-	addr := randIPv4Address(t)
-	err := book.AddAddress(addr, addr)
-	require.NoError(t, err)
-
-	selection = book.GetSelectionWithBias(biasTowardsNewAddrs)
-	assert.Equal(t, 1, len(selection))
-	assert.Equal(t, addr, selection[0])
-
-	// 3) add a bunch of addresses
-	randAddrs := randNetAddressPairs(t, 100)
-	for _, addrSrc := range randAddrs {
-		err := book.AddAddress(addrSrc.addr, addrSrc.src)
-		require.NoError(t, err)
-	}
-
-	// check there is no duplicates
-	addrs := make(map[string]*p2p.NetAddress)
-	selection = book.GetSelectionWithBias(biasTowardsNewAddrs)
-	for _, addr := range selection {
-		if dup, ok := addrs[addr.String()]; ok {
-			t.Fatalf("selection %v contains duplicates %v", selection, dup)
-		}
-		addrs[addr.String()] = addr
-	}
-
-	if len(selection) > book.Size() {
-		t.Fatalf("selection %v could not be bigger than the book", selection)
-	}
-
-	// 4) mark 80% of the addresses as good
-	randAddrsLen := len(randAddrs)
-	for i, addrSrc := range randAddrs {
-		if int((float64(i)/float64(randAddrsLen))*100) >= 20 {
-			book.MarkGood(addrSrc.addr.ID)
-		}
-	}
-
-	selection = book.GetSelectionWithBias(biasTowardsNewAddrs)
-
-	// check that ~70% of addresses returned are good
-	good := 0
-	for _, addr := range selection {
-		if book.IsGood(addr) {
-			good++
-		}
-	}
-
-	got, expected := int((float64(good)/float64(len(selection)))*100), 100-biasTowardsNewAddrs
-
-	// compute some slack to protect against small differences due to rounding:
-	slack := int(math.Round(float64(100) / float64(len(selection))))
-	if got > expected+slack {
-		t.Fatalf(
-			"got more good peers (%% got: %d, %% expected: %d, number of good addrs: %d, total: %d)",
-			got,
-			expected,
-			good,
-			len(selection),
-		)
-	}
-	if got < expected-slack {
-		t.Fatalf(
-			"got fewer good peers (%% got: %d, %% expected: %d, number of good addrs: %d, total: %d)",
-			got,
-			expected,
-			good,
-			len(selection),
-		)
-	}
-}
-
-func TestAddrBookHasAddress(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	addr := randIPv4Address(t)
-	err := book.AddAddress(addr, addr)
-	require.NoError(t, err)
-
-	assert.True(t, book.HasAddress(addr))
-
-	book.RemoveAddress(addr)
-
-	assert.False(t, book.HasAddress(addr))
-}
-
-func testCreatePrivateAddrs(t *testing.T, numAddrs int) ([]*p2p.NetAddress, []string) {
-	t.Helper()
-	addrs := make([]*p2p.NetAddress, numAddrs)
-	for i := 0; i < numAddrs; i++ {
-		addrs[i] = randIPv4Address(t)
-	}
-
-	private := make([]string, numAddrs)
-	for i, addr := range addrs {
-		private[i] = string(addr.ID)
-	}
-	return addrs, private
-}
-
-func TestBanBadPeers(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-
-	addr := randIPv4Address(t)
-	_ = book.AddAddress(addr, addr)
-
-	book.MarkBad(addr, 1*time.Second)
-	// addr should not reachable
-	assert.False(t, book.HasAddress(addr))
-	assert.True(t, book.IsBanned(addr))
-
-	err := book.AddAddress(addr, addr)
-	// book should not add address from the blacklist
-	assert.Error(t, err)
-
-	time.Sleep(1 * time.Second)
-	book.ReinstateBadPeers()
-	// address should be reinstated in the new bucket
-	assert.EqualValues(t, 1, book.Size())
-	assert.True(t, book.HasAddress(addr))
-	assert.False(t, book.IsGood(addr))
-}
-
-func TestAddrBookEmpty(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	// Check that empty book is empty
-	require.True(t, book.Empty())
-	// Check that book with our address is empty
-	book.AddOurAddress(randIPv4Address(t))
-	require.True(t, book.Empty())
-	// Check that book with private addrs is empty
-	_, privateIds := testCreatePrivateAddrs(t, 5)
-	book.AddPrivateIDs(privateIds)
-	require.True(t, book.Empty())
-
-	// Check that book with address is not empty
-	err := book.AddAddress(randIPv4Address(t), randIPv4Address(t))
-	require.NoError(t, err)
-	require.False(t, book.Empty())
-}
-
-func TestPrivatePeers(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-
-	addrs, private := testCreatePrivateAddrs(t, 10)
-	book.AddPrivateIDs(private)
-
-	// private addrs must not be added
-	for _, addr := range addrs {
-		err := book.AddAddress(addr, addr)
-		if assert.Error(t, err) {
-			_, ok := err.(ErrAddrBookPrivate)
-			assert.True(t, ok)
-		}
-	}
-
-	// addrs coming from private peers must not be added
-	err := book.AddAddress(randIPv4Address(t), addrs[0])
-	if assert.Error(t, err) {
-		_, ok := err.(ErrAddrBookPrivateSrc)
-		assert.True(t, ok)
-	}
-}
-
-func testAddrBookAddressSelection(t *testing.T, bookSize int) {
-	// generate all combinations of old (m) and new addresses
-	for nBookOld := 0; nBookOld <= bookSize; nBookOld++ {
-		nBookNew := bookSize - nBookOld
-		dbgStr := fmt.Sprintf("book of size %d (new %d, old %d)", bookSize, nBookNew, nBookOld)
-
-		// create book and get selection
-		book, _ := createAddrBookWithMOldAndNNewAddrs(t, nBookOld, nBookNew)
-		addrs := book.GetSelectionWithBias(biasToSelectNewPeers)
-		assert.NotNil(t, addrs, "%s - expected a non-nil selection", dbgStr)
-		nAddrs := len(addrs)
-		assert.NotZero(t, nAddrs, "%s - expected at least one address in selection", dbgStr)
-
-		// check there's no nil addresses
-		for _, addr := range addrs {
-			if addr == nil {
-				t.Fatalf("%s - got nil address in selection %v", dbgStr, addrs)
-			}
-		}
-
-		// XXX: shadowing
-		nOld, nNew := countOldAndNewAddrsInSelection(addrs, book)
-
-		// Given:
-		// n - num new addrs, m - num old addrs
-		// k - num new addrs expected in the beginning (based on bias %)
-		// i=min(n, max(k,r-m)), aka expNew
-		// j=min(m, r-i), aka expOld
-		//
-		// We expect this layout:
-		// indices:      0...i-1   i...i+j-1
-		// addresses:    N0..Ni-1  O0..Oj-1
-		//
-		// There is at least one partition and at most three.
-		var (
-			k      = percentageOfNum(biasToSelectNewPeers, nAddrs)
-			expNew = tmmath.MinInt(nNew, tmmath.MaxInt(k, nAddrs-nBookOld))
-			expOld = tmmath.MinInt(nOld, nAddrs-expNew)
-		)
-
-		// Verify that the number of old and new addresses are as expected
-		if nNew != expNew {
-			t.Fatalf("%s - expected new addrs %d, got %d", dbgStr, expNew, nNew)
-		}
-		if nOld != expOld {
-			t.Fatalf("%s - expected old addrs %d, got %d", dbgStr, expOld, nOld)
-		}
-
-		// Verify that the order of addresses is as expected
-		// Get the sequence types and lengths of the selection
-		seqLens, seqTypes, err := analyseSelectionLayout(book, addrs)
-		assert.NoError(t, err, "%s", dbgStr)
-
-		// Build a list with the expected lengths of partitions and another with the expected types, e.g.:
-		// expSeqLens = [10, 22], expSeqTypes = [1, 2]
-		// means we expect 10 new (type 1) addresses followed by 22 old (type 2) addresses.
-		var expSeqLens []int
-		var expSeqTypes []int
-
-		switch {
-		case expOld == 0: // all new addresses
-			expSeqLens = []int{nAddrs}
-			expSeqTypes = []int{1}
-		case expNew == 0: // all old addresses
-			expSeqLens = []int{nAddrs}
-			expSeqTypes = []int{2}
-		case nAddrs-expNew-expOld == 0: // new addresses, old addresses
-			expSeqLens = []int{expNew, expOld}
-			expSeqTypes = []int{1, 2}
-		}
-
-		assert.Equal(t, expSeqLens, seqLens,
-			"%s - expected sequence lengths of old/new %v, got %v",
-			dbgStr, expSeqLens, seqLens)
-		assert.Equal(t, expSeqTypes, seqTypes,
-			"%s - expected sequence types (1-new, 2-old) was %v, got %v",
-			dbgStr, expSeqTypes, seqTypes)
-	}
-}
-
-func TestMultipleAddrBookAddressSelection(t *testing.T) {
-	// test books with smaller size, < N
-	const N = 32
-	for bookSize := 1; bookSize < N; bookSize++ {
-		testAddrBookAddressSelection(t, bookSize)
-	}
-
-	// Test for two books with sizes from following ranges
-	ranges := [...][]int{{33, 100}, {100, 175}}
-	bookSizes := make([]int, 0, len(ranges))
-	for _, r := range ranges {
-		bookSizes = append(bookSizes, mrand.Intn(r[1]-r[0])+r[0])
-	}
-	t.Logf("Testing address selection for the following book sizes %v\n", bookSizes)
-	for _, bookSize := range bookSizes {
-		testAddrBookAddressSelection(t, bookSize)
-	}
-}
-
-func TestAddrBookAddDoesNotOverwriteOldIP(t *testing.T) {
-	fname := createTempFileName(t, "addrbook_test")
-
-	// This test creates adds a peer to the address book and marks it good
-	// It then attempts to override the peer's IP, by adding a peer with the same ID
-	// but different IP. We distinguish the IP's by "RealIP" and "OverrideAttemptIP"
-	peerID := "678503e6c8f50db7279c7da3cb9b072aac4bc0d5"
-	peerRealIP := "1.1.1.1:26656"
-	peerOverrideAttemptIP := "2.2.2.2:26656"
-	SrcAddr := "b0dd378c3fbc4c156cd6d302a799f0d2e4227201@159.89.121.174:26656"
-
-	// There is a chance that AddAddress will ignore the new peer its given.
-	// So we repeat trying to override the peer several times,
-	// to ensure we aren't in a case that got probabilistically ignored
-	numOverrideAttempts := 10
-
-	peerRealAddr, err := types.NewNetAddressString(peerID + "@" + peerRealIP)
-	require.Nil(t, err)
-
-	peerOverrideAttemptAddr, err := types.NewNetAddressString(peerID + "@" + peerOverrideAttemptIP)
-	require.Nil(t, err)
-
-	src, err := types.NewNetAddressString(SrcAddr)
-	require.Nil(t, err)
-
-	book := NewAddrBook(fname, true)
-	book.SetLogger(log.TestingLogger())
-	err = book.AddAddress(peerRealAddr, src)
-	require.Nil(t, err)
-	book.MarkAttempt(peerRealAddr)
-	book.MarkGood(peerRealAddr.ID)
-
-	// Double check that adding a peer again doesn't error
-	err = book.AddAddress(peerRealAddr, src)
-	require.Nil(t, err)
-
-	// Try changing ip but keeping the same node id. (change 1.1.1.1 to 2.2.2.2)
-	// This should just be ignored, and not error.
-	for i := 0; i < numOverrideAttempts; i++ {
-		err = book.AddAddress(peerOverrideAttemptAddr, src)
-		require.Nil(t, err)
-	}
-	// Now check that the IP was not overridden.
-	// This is done by sampling several peers from addr book
-	// and ensuring they all have the correct IP.
-	// In the expected functionality, this test should only have 1 Peer, hence will pass.
-	for i := 0; i < numOverrideAttempts; i++ {
-		selection := book.GetSelection()
-		for _, addr := range selection {
-			require.Equal(t, addr.IP, peerRealAddr.IP)
-		}
-	}
-}
-
-func TestAddrBookGroupKey(t *testing.T) {
-	// non-strict routability
-	testCases := []struct {
-		name   string
-		ip     string
-		expKey string
-	}{
-		// IPv4 normal.
-		{"ipv4 normal class a", "12.1.2.3", "12.1.0.0"},
-		{"ipv4 normal class b", "173.1.2.3", "173.1.0.0"},
-		{"ipv4 normal class c", "196.1.2.3", "196.1.0.0"},
-
-		// IPv6/IPv4 translations.
-		{"ipv6 rfc3964 with ipv4 encap", "2002:0c01:0203::", "12.1.0.0"},
-		{"ipv6 rfc4380 toredo ipv4", "2001:0:1234::f3fe:fdfc", "12.1.0.0"},
-		{"ipv6 rfc6052 well-known prefix with ipv4", "64:ff9b::0c01:0203", "12.1.0.0"},
-		{"ipv6 rfc6145 translated ipv4", "::ffff:0:0c01:0203", "12.1.0.0"},
-
-		// Tor.
-		{"ipv6 tor onioncat", "fd87:d87e:eb43:1234::5678", "tor:2"},
-		{"ipv6 tor onioncat 2", "fd87:d87e:eb43:1245::6789", "tor:2"},
-		{"ipv6 tor onioncat 3", "fd87:d87e:eb43:1345::6789", "tor:3"},
-
-		// IPv6 normal.
-		{"ipv6 normal", "2602:100::1", "2602:100::"},
-		{"ipv6 normal 2", "2602:0100::1234", "2602:100::"},
-		{"ipv6 hurricane electric", "2001:470:1f10:a1::2", "2001:470:1000::"},
-		{"ipv6 hurricane electric 2", "2001:0470:1f10:a1::2", "2001:470:1000::"},
-	}
-
-	for i, tc := range testCases {
-		nip := net.ParseIP(tc.ip)
-		key := groupKeyFor(types.NewNetAddressIPPort(nip, 26656), false)
-		assert.Equal(t, tc.expKey, key, "#%d", i)
-	}
-
-	// strict routability
-	testCases = []struct {
-		name   string
-		ip     string
-		expKey string
-	}{
-		// Local addresses.
-		{"ipv4 localhost", "127.0.0.1", "local"},
-		{"ipv6 localhost", "::1", "local"},
-		{"ipv4 zero", "0.0.0.0", "local"},
-		{"ipv4 first octet zero", "0.1.2.3", "local"},
-
-		// Unroutable addresses.
-		{"ipv4 invalid bcast", "255.255.255.255", "unroutable"},
-		{"ipv4 rfc1918 10/8", "10.1.2.3", "unroutable"},
-		{"ipv4 rfc1918 172.16/12", "172.16.1.2", "unroutable"},
-		{"ipv4 rfc1918 192.168/16", "192.168.1.2", "unroutable"},
-		{"ipv6 rfc3849 2001:db8::/32", "2001:db8::1234", "unroutable"},
-		{"ipv4 rfc3927 169.254/16", "169.254.1.2", "unroutable"},
-		{"ipv6 rfc4193 fc00::/7", "fc00::1234", "unroutable"},
-		{"ipv6 rfc4843 2001:10::/28", "2001:10::1234", "unroutable"},
-		{"ipv6 rfc4862 fe80::/64", "fe80::1234", "unroutable"},
-	}
-
-	for i, tc := range testCases {
-		nip := net.ParseIP(tc.ip)
-		key := groupKeyFor(types.NewNetAddressIPPort(nip, 26656), true)
-		assert.Equal(t, tc.expKey, key, "#%d", i)
-	}
-}
-
-func assertMOldAndNNewAddrsInSelection(t *testing.T, m, n int, addrs []*p2p.NetAddress, book *addrBook) {
-	nOld, nNew := countOldAndNewAddrsInSelection(addrs, book)
-	assert.Equal(t, m, nOld, "old addresses")
-	assert.Equal(t, n, nNew, "new addresses")
-}
-
-func createTempFileName(t *testing.T, prefix string) string {
-	t.Helper()
-	f, err := ioutil.TempFile("", prefix)
-	if err != nil {
-		panic(err)
-	}
-
-	fname := f.Name()
-	if err := f.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	t.Cleanup(func() { _ = os.Remove(fname) })
-
-	return fname
-}
-
-func createAddrBookWithMOldAndNNewAddrs(t *testing.T, nOld, nNew int) (book *addrBook, fname string) {
-	t.Helper()
-	fname = createTempFileName(t, "addrbook_test")
-
-	book = NewAddrBook(fname, true).(*addrBook)
-	book.SetLogger(log.TestingLogger())
-	assert.Zero(t, book.Size())
-
-	randAddrs := randNetAddressPairs(t, nOld)
-	for _, addr := range randAddrs {
-		err := book.AddAddress(addr.addr, addr.src)
-		require.NoError(t, err)
-		book.MarkGood(addr.addr.ID)
-	}
-
-	randAddrs = randNetAddressPairs(t, nNew)
-	for _, addr := range randAddrs {
-		err := book.AddAddress(addr.addr, addr.src)
-		require.NoError(t, err)
-	}
-
-	return
-}
-
-func countOldAndNewAddrsInSelection(addrs []*p2p.NetAddress, book *addrBook) (nOld, nNew int) {
-	for _, addr := range addrs {
-		if book.IsGood(addr) {
-			nOld++
-		} else {
-			nNew++
-		}
-	}
-	return
-}
-
-// Analyze the layout of the selection specified by 'addrs'
-// Returns:
-// - seqLens - the lengths of the sequences of addresses of same type
-// - seqTypes - the types of sequences in selection
-func analyseSelectionLayout(book *addrBook, addrs []*p2p.NetAddress) (seqLens, seqTypes []int, err error) {
-	// address types are: 0 - nil, 1 - new, 2 - old
-	var (
-		prevType      = 0
-		currentSeqLen = 0
-	)
-
-	for _, addr := range addrs {
-		addrType := 0
-		if book.IsGood(addr) {
-			addrType = 2
-		} else {
-			addrType = 1
-		}
-		if addrType != prevType && prevType != 0 {
-			seqLens = append(seqLens, currentSeqLen)
-			seqTypes = append(seqTypes, prevType)
-			currentSeqLen = 0
-		}
-		currentSeqLen++
-		prevType = addrType
-	}
-
-	seqLens = append(seqLens, currentSeqLen)
-	seqTypes = append(seqTypes, prevType)
-
-	return
-}
diff --git a/internal/p2p/pex/bench_test.go b/internal/p2p/pex/bench_test.go
deleted file mode 100644
index 37019f60a0..0000000000
--- a/internal/p2p/pex/bench_test.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package pex
-
-import (
-	"testing"
-
-	"github.com/tendermint/tendermint/types"
-)
-
-func BenchmarkAddrBook_hash(b *testing.B) {
-	book := &addrBook{
-		ourAddrs:          make(map[string]struct{}),
-		privateIDs:        make(map[types.NodeID]struct{}),
-		addrLookup:        make(map[types.NodeID]*knownAddress),
-		badPeers:          make(map[types.NodeID]*knownAddress),
-		filePath:          "",
-		routabilityStrict: true,
-	}
-	book.init()
-	msg := []byte(`foobar`)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = book.hash(msg)
-	}
-}
diff --git a/internal/p2p/pex/errors.go b/internal/p2p/pex/errors.go
index 275e71bf9e..4d41cce07c 100644
--- a/internal/p2p/pex/errors.go
+++ b/internal/p2p/pex/errors.go
@@ -15,17 +15,6 @@ func (err ErrAddrBookNonRoutable) Error() string {
 	return fmt.Sprintf("Cannot add non-routable address %v", err.Addr)
 }
 
-type errAddrBookOldAddressNewBucket struct {
-	Addr     *p2p.NetAddress
-	BucketID int
-}
-
-func (err errAddrBookOldAddressNewBucket) Error() string {
-	return fmt.Sprintf("failed consistency check!"+
-		" Cannot add pre-existing address %v into new bucket %v",
-		err.Addr, err.BucketID)
-}
-
 type ErrAddrBookSelf struct {
 	Addr *p2p.NetAddress
 }
diff --git a/internal/p2p/pex/file.go b/internal/p2p/pex/file.go
deleted file mode 100644
index ce65f7d4d3..0000000000
--- a/internal/p2p/pex/file.go
+++ /dev/null
@@ -1,83 +0,0 @@
-package pex
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-
-	"github.com/tendermint/tendermint/internal/libs/tempfile"
-)
-
-/* Loading & Saving */
-
-type addrBookJSON struct {
-	Key   string          `json:"key"`
-	Addrs []*knownAddress `json:"addrs"`
-}
-
-func (a *addrBook) saveToFile(filePath string) {
-	a.mtx.Lock()
-	defer a.mtx.Unlock()
-
-	a.Logger.Info("Saving AddrBook to file", "size", a.size())
-
-	addrs := make([]*knownAddress, 0, len(a.addrLookup))
-	for _, ka := range a.addrLookup {
-		addrs = append(addrs, ka)
-	}
-	aJSON := &addrBookJSON{
-		Key:   a.key,
-		Addrs: addrs,
-	}
-
-	jsonBytes, err := json.MarshalIndent(aJSON, "", "\t")
-	if err != nil {
-		a.Logger.Error("Failed to save AddrBook to file", "err", err)
-		return
-	}
-	err = tempfile.WriteFileAtomic(filePath, jsonBytes, 0644)
-	if err != nil {
-		a.Logger.Error("Failed to save AddrBook to file", "file", filePath, "err", err)
-	}
-}
-
-// Returns false if file does not exist.
-// cmn.Panics if file is corrupt.
-func (a *addrBook) loadFromFile(filePath string) bool {
-	// If doesn't exist, do nothing.
-	_, err := os.Stat(filePath)
-	if os.IsNotExist(err) {
-		return false
-	}
-
-	// Load addrBookJSON{}
-	r, err := os.Open(filePath)
-	if err != nil {
-		panic(fmt.Sprintf("Error opening file %s: %v", filePath, err))
-	}
-	defer r.Close()
-	aJSON := &addrBookJSON{}
-	dec := json.NewDecoder(r)
-	err = dec.Decode(aJSON)
-	if err != nil {
-		panic(fmt.Sprintf("Error reading file %s: %v", filePath, err))
-	}
-
-	// Restore all the fields...
-	// Restore the key
-	a.key = aJSON.Key
-	// Restore .bucketsNew & .bucketsOld
-	for _, ka := range aJSON.Addrs {
-		for _, bucketIndex := range ka.Buckets {
-			bucket := a.getBucket(ka.BucketType, bucketIndex)
-			bucket[ka.Addr.String()] = ka
-		}
-		a.addrLookup[ka.ID()] = ka
-		if ka.BucketType == bucketTypeNew {
-			a.nNew++
-		} else {
-			a.nOld++
-		}
-	}
-	return true
-}
diff --git a/internal/p2p/pex/known_address.go b/internal/p2p/pex/known_address.go
deleted file mode 100644
index 2a2ebe0386..0000000000
--- a/internal/p2p/pex/known_address.go
+++ /dev/null
@@ -1,141 +0,0 @@
-package pex
-
-import (
-	"time"
-
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/types"
-)
-
-// knownAddress tracks information about a known network address
-// that is used to determine how viable an address is.
-type knownAddress struct {
-	Addr        *p2p.NetAddress `json:"addr"`
-	Src         *p2p.NetAddress `json:"src"`
-	Buckets     []int           `json:"buckets"`
-	Attempts    int32           `json:"attempts"`
-	BucketType  byte            `json:"bucket_type"`
-	LastAttempt time.Time       `json:"last_attempt"`
-	LastSuccess time.Time       `json:"last_success"`
-	LastBanTime time.Time       `json:"last_ban_time"`
-}
-
-func newKnownAddress(addr *p2p.NetAddress, src *p2p.NetAddress) *knownAddress {
-	return &knownAddress{
-		Addr:        addr,
-		Src:         src,
-		Attempts:    0,
-		LastAttempt: time.Now(),
-		BucketType:  bucketTypeNew,
-		Buckets:     nil,
-	}
-}
-
-func (ka *knownAddress) ID() types.NodeID {
-	return ka.Addr.ID
-}
-
-func (ka *knownAddress) isOld() bool {
-	return ka.BucketType == bucketTypeOld
-}
-
-func (ka *knownAddress) isNew() bool {
-	return ka.BucketType == bucketTypeNew
-}
-
-func (ka *knownAddress) markAttempt() {
-	now := time.Now()
-	ka.LastAttempt = now
-	ka.Attempts++
-}
-
-func (ka *knownAddress) markGood() {
-	now := time.Now()
-	ka.LastAttempt = now
-	ka.Attempts = 0
-	ka.LastSuccess = now
-}
-
-func (ka *knownAddress) ban(banTime time.Duration) {
-	if ka.LastBanTime.Before(time.Now().Add(banTime)) {
-		ka.LastBanTime = time.Now().Add(banTime)
-	}
-}
-
-func (ka *knownAddress) isBanned() bool {
-	return ka.LastBanTime.After(time.Now())
-}
-
-func (ka *knownAddress) addBucketRef(bucketIdx int) int {
-	for _, bucket := range ka.Buckets {
-		if bucket == bucketIdx {
-			// TODO refactor to return error?
-			// log.Warn(Fmt("Bucket already exists in ka.Buckets: %v", ka))
-			return -1
-		}
-	}
-	ka.Buckets = append(ka.Buckets, bucketIdx)
-	return len(ka.Buckets)
-}
-
-func (ka *knownAddress) removeBucketRef(bucketIdx int) int {
-	buckets := []int{}
-	for _, bucket := range ka.Buckets {
-		if bucket != bucketIdx {
-			buckets = append(buckets, bucket)
-		}
-	}
-	if len(buckets) != len(ka.Buckets)-1 {
-		// TODO refactor to return error?
-		// log.Warn(Fmt("bucketIdx not found in ka.Buckets: %v", ka))
-		return -1
-	}
-	ka.Buckets = buckets
-	return len(ka.Buckets)
-}
-
-/*
-   An address is bad if the address in question is a New address, has not been tried in the last
-   minute, and meets one of the following criteria:
-
-   1) It claims to be from the future
-   2) It hasn't been seen in over a week
-   3) It has failed at least three times and never succeeded
-   4) It has failed ten times in the last week
-
-   All addresses that meet these criteria are assumed to be worthless and not
-   worth keeping hold of.
-
-*/
-func (ka *knownAddress) isBad() bool {
-	// Is Old --> good
-	if ka.BucketType == bucketTypeOld {
-		return false
-	}
-
-	// Has been attempted in the last minute --> good
-	if ka.LastAttempt.After(time.Now().Add(-1 * time.Minute)) {
-		return false
-	}
-
-	// TODO: From the future?
-
-	// Too old?
-	// TODO: should be a timestamp of last seen, not just last attempt
-	if ka.LastAttempt.Before(time.Now().Add(-1 * numMissingDays * time.Hour * 24)) {
-		return true
-	}
-
-	// Never succeeded?
-	if ka.LastSuccess.IsZero() && ka.Attempts >= numRetries {
-		return true
-	}
-
-	// Hasn't succeeded in too long?
-	if ka.LastSuccess.Before(time.Now().Add(-1*minBadDays*time.Hour*24)) &&
-		ka.Attempts >= maxFailures {
-		return true
-	}
-
-	return false
-}
diff --git a/internal/p2p/pex/params.go b/internal/p2p/pex/params.go
deleted file mode 100644
index 29b4d45ab2..0000000000
--- a/internal/p2p/pex/params.go
+++ /dev/null
@@ -1,55 +0,0 @@
-package pex
-
-import "time"
-
-const (
-	// addresses under which the address manager will claim to need more addresses.
-	needAddressThreshold = 1000
-
-	// interval used to dump the address cache to disk for future use.
-	dumpAddressInterval = time.Minute * 2
-
-	// max addresses in each old address bucket.
-	oldBucketSize = 64
-
-	// buckets we split old addresses over.
-	oldBucketCount = 64
-
-	// max addresses in each new address bucket.
-	newBucketSize = 64
-
-	// buckets that we spread new addresses over.
-	newBucketCount = 256
-
-	// old buckets over which an address group will be spread.
-	oldBucketsPerGroup = 4
-
-	// new buckets over which a source address group will be spread.
-	newBucketsPerGroup = 32
-
-	// buckets a frequently seen new address may end up in.
-	maxNewBucketsPerAddress = 4
-
-	// days before which we assume an address has vanished
-	// if we have not seen it announced in that long.
-	numMissingDays = 7
-
-	// tries without a single success before we assume an address is bad.
-	numRetries = 3
-
-	// max failures we will accept without a success before considering an address bad.
-	maxFailures = 10 // ?
-
-	// days since the last success before we will consider evicting an address.
-	minBadDays = 7
-
-	// % of total addresses known returned by GetSelection.
-	getSelectionPercent = 23
-
-	// min addresses that must be returned by GetSelection. Useful for bootstrapping.
-	minGetSelection = 32
-
-	// max addresses returned by GetSelection
-	// NOTE: this must match "maxMsgSize"
-	maxGetSelection = 250
-)
diff --git a/internal/p2p/pex/pex_reactor.go b/internal/p2p/pex/pex_reactor.go
deleted file mode 100644
index 9eb58c054c..0000000000
--- a/internal/p2p/pex/pex_reactor.go
+++ /dev/null
@@ -1,862 +0,0 @@
-package pex
-
-import (
-	"errors"
-	"fmt"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/gogo/protobuf/proto"
-
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
-	"github.com/tendermint/tendermint/libs/cmap"
-	tmmath "github.com/tendermint/tendermint/libs/math"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
-	"github.com/tendermint/tendermint/libs/service"
-	tmp2p "github.com/tendermint/tendermint/proto/tendermint/p2p"
-	"github.com/tendermint/tendermint/types"
-)
-
-type Peer = p2p.Peer
-
-const (
-	// PexChannel is a channel for PEX messages
-	PexChannel = byte(0x00)
-
-	// over-estimate of max NetAddress size
-	// hexID (40) + IP (16) + Port (2) + Name (100) ...
-	// NOTE: dont use massive DNS name ..
-	maxAddressSize = 256
-
-	// NOTE: amplificaiton factor!
-	// small request results in up to maxMsgSize response
-	maxMsgSize = maxAddressSize * maxGetSelection
-
-	// ensure we have enough peers
-	defaultEnsurePeersPeriod = 30 * time.Second
-
-	// Seed/Crawler constants
-
-	// minTimeBetweenCrawls is a minimum time between attempts to crawl a peer.
-	minTimeBetweenCrawls = 2 * time.Minute
-
-	// check some peers every this
-	crawlPeerPeriod = 30 * time.Second
-
-	maxAttemptsToDial = 16 // ~ 35h in total (last attempt - 18h)
-
-	// if node connects to seed, it does not have any trusted peers.
-	// Especially in the beginning, node should have more trusted peers than
-	// untrusted.
-	biasToSelectNewPeers = 30 // 70 to select good peers
-
-	// if a peer is marked bad, it will be banned for at least this time period
-	defaultBanTime = 24 * time.Hour
-)
-
-type errMaxAttemptsToDial struct {
-}
-
-func (e errMaxAttemptsToDial) Error() string {
-	return fmt.Sprintf("reached max attempts %d to dial", maxAttemptsToDial)
-}
-
-type errTooEarlyToDial struct {
-	backoffDuration time.Duration
-	lastDialed      time.Time
-}
-
-func (e errTooEarlyToDial) Error() string {
-	return fmt.Sprintf(
-		"too early to dial (backoff duration: %d, last dialed: %v, time since: %v)",
-		e.backoffDuration, e.lastDialed, time.Since(e.lastDialed))
-}
-
-// Reactor handles PEX (peer exchange) and ensures that an
-// adequate number of peers are connected to the switch.
-//
-// It uses `AddrBook` (address book) to store `NetAddress`es of the peers.
-//
-// ## Preventing abuse
-//
-// Only accept pexAddrsMsg from peers we sent a corresponding pexRequestMsg too.
-// Only accept one pexRequestMsg every ~defaultEnsurePeersPeriod.
-type Reactor struct {
-	p2p.BaseReactor
-
-	book              AddrBook
-	config            *ReactorConfig
-	ensurePeersPeriod time.Duration // TODO: should go in the config
-
-	// maps to prevent abuse
-	requestsSent         *cmap.CMap // ID->struct{}: unanswered send requests
-	lastReceivedRequests *cmap.CMap // ID->time.Time: last time peer requested from us
-
-	seedAddrs []*p2p.NetAddress
-
-	attemptsToDial sync.Map // address (string) -> {number of attempts (int), last time dialed (time.Time)}
-
-	// seed/crawled mode fields
-	crawlPeerInfos map[types.NodeID]crawlPeerInfo
-}
-
-func (r *Reactor) minReceiveRequestInterval() time.Duration {
-	// NOTE: must be less than ensurePeersPeriod, otherwise we'll request
-	// peers too quickly from others and they'll think we're bad!
-	return r.ensurePeersPeriod / 3
-}
-
-// ReactorConfig holds reactor specific configuration data.
-type ReactorConfig struct {
-	// Seed/Crawler mode
-	SeedMode bool
-
-	// We want seeds to only advertise good peers. Therefore they should wait at
-	// least as long as we expect it to take for a peer to become good before
-	// disconnecting.
-	SeedDisconnectWaitPeriod time.Duration
-
-	// Maximum pause when redialing a persistent peer (if zero, exponential backoff is used)
-	PersistentPeersMaxDialPeriod time.Duration
-
-	// Seeds is a list of addresses reactor may use
-	// if it can't connect to peers in the addrbook.
-	Seeds []string
-}
-
-type _attemptsToDial struct {
-	number     int
-	lastDialed time.Time
-}
-
-// NewReactor creates new PEX reactor.
-func NewReactor(b AddrBook, config *ReactorConfig) *Reactor {
-	r := &Reactor{
-		book:                 b,
-		config:               config,
-		ensurePeersPeriod:    defaultEnsurePeersPeriod,
-		requestsSent:         cmap.NewCMap(),
-		lastReceivedRequests: cmap.NewCMap(),
-		crawlPeerInfos:       make(map[types.NodeID]crawlPeerInfo),
-	}
-	r.BaseReactor = *p2p.NewBaseReactor("PEX", r)
-	return r
-}
-
-// OnStart implements BaseService
-func (r *Reactor) OnStart() error {
-	err := r.book.Start()
-	if err != nil && err != service.ErrAlreadyStarted {
-		return err
-	}
-
-	numOnline, seedAddrs, err := r.checkSeeds()
-	if err != nil {
-		return err
-	} else if numOnline == 0 && r.book.Empty() {
-		return errors.New("address book is empty and couldn't resolve any seed nodes")
-	}
-
-	r.seedAddrs = seedAddrs
-
-	// Check if this node should run
-	// in seed/crawler mode
-	if r.config.SeedMode {
-		go r.crawlPeersRoutine()
-	} else {
-		go r.ensurePeersRoutine()
-	}
-	return nil
-}
-
-// OnStop implements BaseService
-func (r *Reactor) OnStop() {
-	if err := r.book.Stop(); err != nil {
-		r.Logger.Error("Error stopping address book", "err", err)
-	}
-}
-
-// GetChannels implements Reactor
-func (r *Reactor) GetChannels() []*conn.ChannelDescriptor {
-	return []*conn.ChannelDescriptor{
-		{
-			ID:                  PexChannel,
-			Priority:            1,
-			SendQueueCapacity:   10,
-			RecvMessageCapacity: maxMsgSize,
-
-			MaxSendBytes: 200,
-		},
-	}
-}
-
-// AddPeer implements Reactor by adding peer to the address book (if inbound)
-// or by requesting more addresses (if outbound).
-func (r *Reactor) AddPeer(p Peer) {
-	if p.IsOutbound() {
-		// For outbound peers, the address is already in the books -
-		// either via DialPeersAsync or r.Receive.
-		// Ask it for more peers if we need.
-		if r.book.NeedMoreAddrs() {
-			r.RequestAddrs(p)
-		}
-	} else {
-		// inbound peer is its own source
-		addr, err := p.NodeInfo().NetAddress()
-		if err != nil {
-			r.Logger.Error("Failed to get peer NetAddress", "err", err, "peer", p)
-			return
-		}
-
-		// Make it explicit that addr and src are the same for an inbound peer.
-		src := addr
-
-		// add to book. dont RequestAddrs right away because
-		// we don't trust inbound as much - let ensurePeersRoutine handle it.
-		err = r.book.AddAddress(addr, src)
-		r.logErrAddrBook(err)
-	}
-}
-
-// RemovePeer implements Reactor by resetting peer's requests info.
-func (r *Reactor) RemovePeer(p Peer, reason interface{}) {
-	id := string(p.ID())
-	r.requestsSent.Delete(id)
-	r.lastReceivedRequests.Delete(id)
-}
-
-func (r *Reactor) logErrAddrBook(err error) {
-	if err != nil {
-		switch err.(type) {
-		case ErrAddrBookNilAddr:
-			r.Logger.Error("Failed to add new address", "err", err)
-		default:
-			// non-routable, self, full book, private, etc.
-			r.Logger.Debug("Failed to add new address", "err", err)
-		}
-	}
-}
-
-// Receive implements Reactor by handling incoming PEX messages.
-// XXX: do not call any methods that can block or incur heavy processing.
-// https://github.com/tendermint/tendermint/issues/2888
-func (r *Reactor) Receive(chID byte, src Peer, msgBytes []byte) {
-	msg, err := decodeMsg(msgBytes)
-	if err != nil {
-		r.Logger.Error("Error decoding message", "src", src, "chId", chID, "err", err)
-		r.Switch.StopPeerForError(src, err)
-		return
-	}
-	r.Logger.Debug("Received message", "src", src, "chId", chID, "msg", msg)
-
-	switch msg := msg.(type) {
-	case *tmp2p.PexRequest:
-
-		// NOTE: this is a prime candidate for amplification attacks,
-		// so it's important we
-		// 1) restrict how frequently peers can request
-		// 2) limit the output size
-
-		// If we're a seed and this is an inbound peer,
-		// respond once and disconnect.
-		if r.config.SeedMode && !src.IsOutbound() {
-			id := string(src.ID())
-			v := r.lastReceivedRequests.Get(id)
-			if v != nil {
-				// FlushStop/StopPeer are already
-				// running in a go-routine.
-				return
-			}
-			r.lastReceivedRequests.Set(id, time.Now())
-
-			// Send addrs and disconnect
-			r.SendAddrs(src, r.book.GetSelectionWithBias(biasToSelectNewPeers))
-			go func() {
-				// In a go-routine so it doesn't block .Receive.
-				src.FlushStop()
-				r.Switch.StopPeerGracefully(src)
-			}()
-
-		} else {
-			// Check we're not receiving requests too frequently.
-			if err := r.receiveRequest(src); err != nil {
-				r.Switch.StopPeerForError(src, err)
-				r.book.MarkBad(src.SocketAddr(), defaultBanTime)
-				return
-			}
-			r.SendAddrs(src, r.book.GetSelection())
-		}
-
-	case *tmp2p.PexResponse:
-		// If we asked for addresses, add them to the book
-		addrs, err := NetAddressesFromProto(msg.Addresses)
-		if err != nil {
-			r.Switch.StopPeerForError(src, err)
-			r.book.MarkBad(src.SocketAddr(), defaultBanTime)
-			return
-		}
-		err = r.ReceiveAddrs(addrs, src)
-		if err != nil {
-			r.Switch.StopPeerForError(src, err)
-			if err == ErrUnsolicitedList {
-				r.book.MarkBad(src.SocketAddr(), defaultBanTime)
-			}
-			return
-		}
-
-	default:
-		r.Logger.Error(fmt.Sprintf("Unknown message type %T", msg))
-	}
-}
-
-// enforces a minimum amount of time between requests
-func (r *Reactor) receiveRequest(src Peer) error {
-	id := string(src.ID())
-	v := r.lastReceivedRequests.Get(id)
-	if v == nil {
-		// initialize with empty time
-		lastReceived := time.Time{}
-		r.lastReceivedRequests.Set(id, lastReceived)
-		return nil
-	}
-
-	lastReceived := v.(time.Time)
-	if lastReceived.Equal(time.Time{}) {
-		// first time gets a free pass. then we start tracking the time
-		lastReceived = time.Now()
-		r.lastReceivedRequests.Set(id, lastReceived)
-		return nil
-	}
-
-	now := time.Now()
-	minInterval := r.minReceiveRequestInterval()
-	if now.Sub(lastReceived) < minInterval {
-		return fmt.Errorf(
-			"peer (%v) sent next PEX request too soon. lastReceived: %v, now: %v, minInterval: %v. Disconnecting",
-			src.ID(),
-			lastReceived,
-			now,
-			minInterval,
-		)
-	}
-	r.lastReceivedRequests.Set(id, now)
-	return nil
-}
-
-// RequestAddrs asks peer for more addresses if we do not already have a
-// request out for this peer.
-func (r *Reactor) RequestAddrs(p Peer) {
-	id := string(p.ID())
-	if _, exists := r.requestsSent.GetOrSet(id, struct{}{}); exists {
-		return
-	}
-	r.Logger.Debug("Request addrs", "from", p)
-	p.Send(PexChannel, mustEncode(&tmp2p.PexRequest{}))
-}
-
-// ReceiveAddrs adds the given addrs to the addrbook if theres an open
-// request for this peer and deletes the open request.
-// If there's no open request for the src peer, it returns an error.
-func (r *Reactor) ReceiveAddrs(addrs []*p2p.NetAddress, src Peer) error {
-	id := string(src.ID())
-	if !r.requestsSent.Has(id) {
-		return ErrUnsolicitedList
-	}
-	r.requestsSent.Delete(id)
-
-	srcAddr, err := src.NodeInfo().NetAddress()
-	if err != nil {
-		return err
-	}
-
-	srcIsSeed := false
-	for _, seedAddr := range r.seedAddrs {
-		if seedAddr.Equals(srcAddr) {
-			srcIsSeed = true
-			break
-		}
-	}
-
-	for _, netAddr := range addrs {
-		// NOTE: we check netAddr validity and routability in book#AddAddress.
-		err = r.book.AddAddress(netAddr, srcAddr)
-		if err != nil {
-			r.logErrAddrBook(err)
-			// XXX: should we be strict about incoming data and disconnect from a
-			// peer here too?
-			continue
-		}
-
-		// If this address came from a seed node, try to connect to it without
-		// waiting (#2093)
-		if srcIsSeed {
-			r.Logger.Info("Will dial address, which came from seed", "addr", netAddr, "seed", srcAddr)
-			go func(addr *p2p.NetAddress) {
-				err := r.dialPeer(addr)
-				if err != nil {
-					switch err.(type) {
-					case errMaxAttemptsToDial, errTooEarlyToDial, p2p.ErrCurrentlyDialingOrExistingAddress:
-						r.Logger.Debug(err.Error(), "addr", addr)
-					default:
-						r.Logger.Error(err.Error(), "addr", addr)
-					}
-				}
-			}(netAddr)
-		}
-	}
-
-	return nil
-}
-
-// SendAddrs sends addrs to the peer.
-func (r *Reactor) SendAddrs(p Peer, netAddrs []*p2p.NetAddress) {
-	p.Send(PexChannel, mustEncode(&tmp2p.PexResponse{Addresses: NetAddressesToProto(netAddrs)}))
-}
-
-// SetEnsurePeersPeriod sets period to ensure peers connected.
-func (r *Reactor) SetEnsurePeersPeriod(d time.Duration) {
-	r.ensurePeersPeriod = d
-}
-
-// Ensures that sufficient peers are connected. (continuous)
-func (r *Reactor) ensurePeersRoutine() {
-	var (
-		seed   = tmrand.NewRand()
-		jitter = seed.Int63n(r.ensurePeersPeriod.Nanoseconds())
-	)
-
-	// Randomize first round of communication to avoid thundering herd.
-	// If no peers are present directly start connecting so we guarantee swift
-	// setup with the help of configured seeds.
-	if r.nodeHasSomePeersOrDialingAny() {
-		time.Sleep(time.Duration(jitter))
-	}
-
-	// fire once immediately.
-	// ensures we dial the seeds right away if the book is empty
-	r.ensurePeers()
-
-	// fire periodically
-	ticker := time.NewTicker(r.ensurePeersPeriod)
-	for {
-		select {
-		case <-ticker.C:
-			r.ensurePeers()
-		case <-r.Quit():
-			ticker.Stop()
-			return
-		}
-	}
-}
-
-// ensurePeers ensures that sufficient peers are connected. (once)
-//
-// heuristic that we haven't perfected yet, or, perhaps is manually edited by
-// the node operator. It should not be used to compute what addresses are
-// already connected or not.
-func (r *Reactor) ensurePeers() {
-	var (
-		out, in, dial = r.Switch.NumPeers()
-		numToDial     = r.Switch.MaxNumOutboundPeers() - (out + dial)
-	)
-	r.Logger.Info(
-		"Ensure peers",
-		"numOutPeers", out,
-		"numInPeers", in,
-		"numDialing", dial,
-		"numToDial", numToDial,
-	)
-
-	if numToDial <= 0 {
-		return
-	}
-
-	// bias to prefer more vetted peers when we have fewer connections.
-	// not perfect, but somewhate ensures that we prioritize connecting to more-vetted
-	// NOTE: range here is [10, 90]. Too high ?
-	newBias := tmmath.MinInt(out, 8)*10 + 10
-
-	toDial := make(map[types.NodeID]*p2p.NetAddress)
-	// Try maxAttempts times to pick numToDial addresses to dial
-	maxAttempts := numToDial * 3
-
-	for i := 0; i < maxAttempts && len(toDial) < numToDial; i++ {
-		try := r.book.PickAddress(newBias)
-		if try == nil {
-			continue
-		}
-		if _, selected := toDial[try.ID]; selected {
-			continue
-		}
-		if r.Switch.IsDialingOrExistingAddress(try) {
-			continue
-		}
-		// TODO: consider moving some checks from toDial into here
-		// so we don't even consider dialing peers that we want to wait
-		// before dialing again, or have dialed too many times already
-		r.Logger.Info("Will dial address", "addr", try)
-		toDial[try.ID] = try
-	}
-
-	// Dial picked addresses
-	for _, addr := range toDial {
-		go func(addr *p2p.NetAddress) {
-			err := r.dialPeer(addr)
-			if err != nil {
-				switch err.(type) {
-				case errMaxAttemptsToDial, errTooEarlyToDial:
-					r.Logger.Debug(err.Error(), "addr", addr)
-				default:
-					r.Logger.Error(err.Error(), "addr", addr)
-				}
-			}
-		}(addr)
-	}
-
-	if r.book.NeedMoreAddrs() {
-		// Check if banned nodes can be reinstated
-		r.book.ReinstateBadPeers()
-	}
-
-	if r.book.NeedMoreAddrs() {
-
-		// 1) Pick a random peer and ask for more.
-		peers := r.Switch.Peers().List()
-		peersCount := len(peers)
-		if peersCount > 0 {
-			rand := tmrand.NewRand()
-			peer := peers[rand.Int()%peersCount]
-			r.Logger.Info("We need more addresses. Sending pexRequest to random peer", "peer", peer)
-			r.RequestAddrs(peer)
-		}
-
-		// 2) Dial seeds if we are not dialing anyone.
-		// This is done in addition to asking a peer for addresses to work-around
-		// peers not participating in PEX.
-		if len(toDial) == 0 {
-			r.Logger.Info("No addresses to dial. Falling back to seeds")
-			r.dialSeeds()
-		}
-	}
-}
-
-func (r *Reactor) dialAttemptsInfo(addr *p2p.NetAddress) (attempts int, lastDialed time.Time) {
-	_attempts, ok := r.attemptsToDial.Load(addr.DialString())
-	if !ok {
-		return
-	}
-	atd := _attempts.(_attemptsToDial)
-	return atd.number, atd.lastDialed
-}
-
-func (r *Reactor) dialPeer(addr *p2p.NetAddress) error {
-	attempts, lastDialed := r.dialAttemptsInfo(addr)
-	if !r.Switch.IsPeerPersistent(addr) && attempts > maxAttemptsToDial {
-		r.book.MarkBad(addr, defaultBanTime)
-		return errMaxAttemptsToDial{}
-	}
-
-	// exponential backoff if it's not our first attempt to dial given address
-	if attempts > 0 {
-		rand := tmrand.NewRand()
-		jitter := time.Duration(rand.Float64() * float64(time.Second)) // 1s == (1e9 ns)
-		backoffDuration := jitter + ((1 << uint(attempts)) * time.Second)
-		backoffDuration = r.maxBackoffDurationForPeer(addr, backoffDuration)
-		sinceLastDialed := time.Since(lastDialed)
-		if sinceLastDialed < backoffDuration {
-			return errTooEarlyToDial{backoffDuration, lastDialed}
-		}
-	}
-
-	err := r.Switch.DialPeerWithAddress(addr)
-	if err != nil {
-		if _, ok := err.(p2p.ErrCurrentlyDialingOrExistingAddress); ok {
-			return err
-		}
-
-		markAddrInBookBasedOnErr(addr, r.book, err)
-		switch err.(type) {
-		case p2p.ErrSwitchAuthenticationFailure:
-			// NOTE: addr is removed from addrbook in markAddrInBookBasedOnErr
-			r.attemptsToDial.Delete(addr.DialString())
-		default:
-			r.attemptsToDial.Store(addr.DialString(), _attemptsToDial{attempts + 1, time.Now()})
-		}
-		return fmt.Errorf("dialing failed (attempts: %d): %w", attempts+1, err)
-	}
-
-	// cleanup any history
-	r.attemptsToDial.Delete(addr.DialString())
-	return nil
-}
-
-// maxBackoffDurationForPeer caps the backoff duration for persistent peers.
-func (r *Reactor) maxBackoffDurationForPeer(addr *p2p.NetAddress, planned time.Duration) time.Duration {
-	if r.config.PersistentPeersMaxDialPeriod > 0 &&
-		planned > r.config.PersistentPeersMaxDialPeriod &&
-		r.Switch.IsPeerPersistent(addr) {
-		return r.config.PersistentPeersMaxDialPeriod
-	}
-	return planned
-}
-
-// checkSeeds checks that addresses are well formed.
-// Returns number of seeds we can connect to, along with all seeds addrs.
-// return err if user provided any badly formatted seed addresses.
-// Doesn't error if the seed node can't be reached.
-// numOnline returns -1 if no seed nodes were in the initial configuration.
-func (r *Reactor) checkSeeds() (numOnline int, netAddrs []*p2p.NetAddress, err error) {
-	lSeeds := len(r.config.Seeds)
-	if lSeeds == 0 {
-		return -1, nil, nil
-	}
-	netAddrs, errs := p2p.NewNetAddressStrings(r.config.Seeds)
-	numOnline = lSeeds - len(errs)
-	for _, err := range errs {
-		switch e := err.(type) {
-		case types.ErrNetAddressLookup:
-			r.Logger.Error("Connecting to seed failed", "err", e)
-		default:
-			return 0, nil, fmt.Errorf("seed node configuration has error: %w", e)
-		}
-	}
-	return numOnline, netAddrs, nil
-}
-
-// randomly dial seeds until we connect to one or exhaust them
-func (r *Reactor) dialSeeds() {
-	rand := tmrand.NewRand()
-	perm := rand.Perm(len(r.seedAddrs))
-	// perm := r.Switch.rng.Perm(lSeeds)
-	for _, i := range perm {
-		// dial a random seed
-		seedAddr := r.seedAddrs[i]
-		err := r.Switch.DialPeerWithAddress(seedAddr)
-
-		switch err.(type) {
-		case nil, p2p.ErrCurrentlyDialingOrExistingAddress:
-			return
-		}
-		r.Switch.Logger.Error("Error dialing seed", "err", err, "seed", seedAddr)
-	}
-	// do not write error message if there were no seeds specified in config
-	if len(r.seedAddrs) > 0 {
-		r.Switch.Logger.Error("Couldn't connect to any seeds")
-	}
-}
-
-// AttemptsToDial returns the number of attempts to dial specific address. It
-// returns 0 if never attempted or successfully connected.
-func (r *Reactor) AttemptsToDial(addr *p2p.NetAddress) int {
-	lAttempts, attempted := r.attemptsToDial.Load(addr.DialString())
-	if attempted {
-		return lAttempts.(_attemptsToDial).number
-	}
-	return 0
-}
-
-//----------------------------------------------------------
-
-// Explores the network searching for more peers. (continuous)
-// Seed/Crawler Mode causes this node to quickly disconnect
-// from peers, except other seed nodes.
-func (r *Reactor) crawlPeersRoutine() {
-	// If we have any seed nodes, consult them first
-	if len(r.seedAddrs) > 0 {
-		r.dialSeeds()
-	} else {
-		// Do an initial crawl
-		r.crawlPeers(r.book.GetSelection())
-	}
-
-	// Fire periodically
-	ticker := time.NewTicker(crawlPeerPeriod)
-
-	for {
-		select {
-		case <-ticker.C:
-			r.attemptDisconnects()
-			r.crawlPeers(r.book.GetSelection())
-			r.cleanupCrawlPeerInfos()
-		case <-r.Quit():
-			return
-		}
-	}
-}
-
-// nodeHasSomePeersOrDialingAny returns true if the node is connected to some
-// peers or dialing them currently.
-func (r *Reactor) nodeHasSomePeersOrDialingAny() bool {
-	out, in, dial := r.Switch.NumPeers()
-	return out+in+dial > 0
-}
-
-// crawlPeerInfo handles temporary data needed for the network crawling
-// performed during seed/crawler mode.
-type crawlPeerInfo struct {
-	Addr *p2p.NetAddress `json:"addr"`
-	// The last time we crawled the peer or attempted to do so.
-	LastCrawled time.Time `json:"last_crawled"`
-}
-
-// crawlPeers will crawl the network looking for new peer addresses.
-func (r *Reactor) crawlPeers(addrs []*p2p.NetAddress) {
-	now := time.Now()
-
-	for _, addr := range addrs {
-		peerInfo, ok := r.crawlPeerInfos[addr.ID]
-
-		// Do not attempt to connect with peers we recently crawled.
-		if ok && now.Sub(peerInfo.LastCrawled) < minTimeBetweenCrawls {
-			continue
-		}
-
-		// Record crawling attempt.
-		r.crawlPeerInfos[addr.ID] = crawlPeerInfo{
-			Addr:        addr,
-			LastCrawled: now,
-		}
-
-		err := r.dialPeer(addr)
-		if err != nil {
-			switch err.(type) {
-			case errMaxAttemptsToDial, errTooEarlyToDial, p2p.ErrCurrentlyDialingOrExistingAddress:
-				r.Logger.Debug(err.Error(), "addr", addr)
-			default:
-				r.Logger.Error(err.Error(), "addr", addr)
-			}
-			continue
-		}
-
-		peer := r.Switch.Peers().Get(addr.ID)
-		if peer != nil {
-			r.RequestAddrs(peer)
-		}
-	}
-}
-
-func (r *Reactor) cleanupCrawlPeerInfos() {
-	for id, info := range r.crawlPeerInfos {
-		// If we did not crawl a peer for 24 hours, it means the peer was removed
-		// from the addrbook => remove
-		//
-		// 10000 addresses / maxGetSelection = 40 cycles to get all addresses in
-		// the ideal case,
-		// 40 * crawlPeerPeriod ~ 20 minutes
-		if time.Since(info.LastCrawled) > 24*time.Hour {
-			delete(r.crawlPeerInfos, id)
-		}
-	}
-}
-
-// attemptDisconnects checks if we've been with each peer long enough to disconnect
-func (r *Reactor) attemptDisconnects() {
-	for _, peer := range r.Switch.Peers().List() {
-		if peer.Status().Duration < r.config.SeedDisconnectWaitPeriod {
-			continue
-		}
-		if peer.IsPersistent() {
-			continue
-		}
-		r.Switch.StopPeerGracefully(peer)
-	}
-}
-
-func markAddrInBookBasedOnErr(addr *p2p.NetAddress, book AddrBook, err error) {
-	// TODO: detect more "bad peer" scenarios
-	switch err.(type) {
-	case p2p.ErrSwitchAuthenticationFailure:
-		book.MarkBad(addr, defaultBanTime)
-	default:
-		book.MarkAttempt(addr)
-	}
-}
-
-//-----------------------------------------------------------------------------
-// Messages
-
-// mustEncode proto encodes a tmp2p.Message
-func mustEncode(pb proto.Message) []byte {
-	msg := tmp2p.PexMessage{}
-	switch pb := pb.(type) {
-	case *tmp2p.PexRequest:
-		msg.Sum = &tmp2p.PexMessage_PexRequest{PexRequest: pb}
-	case *tmp2p.PexResponse:
-		msg.Sum = &tmp2p.PexMessage_PexResponse{PexResponse: pb}
-	default:
-		panic(fmt.Sprintf("Unknown message type %T", pb))
-	}
-
-	bz, err := msg.Marshal()
-	if err != nil {
-		panic(fmt.Errorf("unable to marshal %T: %w", pb, err))
-	}
-	return bz
-}
-
-func decodeMsg(bz []byte) (proto.Message, error) {
-	pb := &tmp2p.PexMessage{}
-
-	err := pb.Unmarshal(bz)
-	if err != nil {
-		return nil, err
-	}
-
-	switch msg := pb.Sum.(type) {
-	case *tmp2p.PexMessage_PexRequest:
-		return msg.PexRequest, nil
-	case *tmp2p.PexMessage_PexResponse:
-		return msg.PexResponse, nil
-	default:
-		return nil, fmt.Errorf("unknown message: %T", msg)
-	}
-}
-
-//-----------------------------------------------------------------------------
-// address converters
-
-// NetAddressFromProto converts a Protobuf PexAddress into a native struct.
-func NetAddressFromProto(pb tmp2p.PexAddress) (*types.NetAddress, error) {
-	ip := net.ParseIP(pb.IP)
-	if ip == nil {
-		return nil, fmt.Errorf("invalid IP address %v", pb.IP)
-	}
-	if pb.Port >= 1<<16 {
-		return nil, fmt.Errorf("invalid port number %v", pb.Port)
-	}
-	return &types.NetAddress{
-		ID:   types.NodeID(pb.ID),
-		IP:   ip,
-		Port: uint16(pb.Port),
-	}, nil
-}
-
-// NetAddressesFromProto converts a slice of Protobuf PexAddresses into a native slice.
-func NetAddressesFromProto(pbs []tmp2p.PexAddress) ([]*types.NetAddress, error) {
-	nas := make([]*types.NetAddress, 0, len(pbs))
-	for _, pb := range pbs {
-		na, err := NetAddressFromProto(pb)
-		if err != nil {
-			return nil, err
-		}
-		nas = append(nas, na)
-	}
-	return nas, nil
-}
-
-// NetAddressesToProto converts a slice of NetAddresses into a Protobuf PexAddress slice.
-func NetAddressesToProto(nas []*types.NetAddress) []tmp2p.PexAddress {
-	pbs := make([]tmp2p.PexAddress, 0, len(nas))
-	for _, na := range nas {
-		if na != nil {
-			pbs = append(pbs, tmp2p.PexAddress{
-				ID:   string(na.ID),
-				IP:   na.IP.String(),
-				Port: uint32(na.Port),
-			})
-		}
-	}
-	return pbs
-}
diff --git a/internal/p2p/pex/pex_reactor_test.go b/internal/p2p/pex/pex_reactor_test.go
deleted file mode 100644
index 56f24457f3..0000000000
--- a/internal/p2p/pex/pex_reactor_test.go
+++ /dev/null
@@ -1,680 +0,0 @@
-package pex
-
-import (
-	"encoding/hex"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"github.com/gogo/protobuf/proto"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/mock"
-	"github.com/tendermint/tendermint/libs/log"
-	tmp2p "github.com/tendermint/tendermint/proto/tendermint/p2p"
-	"github.com/tendermint/tendermint/types"
-)
-
-var (
-	cfg *config.P2PConfig
-)
-
-func init() {
-	cfg = config.DefaultP2PConfig()
-	cfg.PexReactor = true
-	cfg.AllowDuplicateIP = true
-}
-
-func TestPEXReactorBasic(t *testing.T) {
-	r, _ := createReactor(t, &ReactorConfig{})
-
-	assert.NotNil(t, r)
-	assert.NotEmpty(t, r.GetChannels())
-}
-
-func TestPEXReactorAddRemovePeer(t *testing.T) {
-	r, book := createReactor(t, &ReactorConfig{})
-
-	size := book.Size()
-	peer := p2p.CreateRandomPeer(false)
-
-	r.AddPeer(peer)
-	assert.Equal(t, size+1, book.Size())
-
-	r.RemovePeer(peer, "peer not available")
-
-	outboundPeer := p2p.CreateRandomPeer(true)
-
-	r.AddPeer(outboundPeer)
-	assert.Equal(t, size+1, book.Size(), "outbound peers should not be added to the address book")
-
-	r.RemovePeer(outboundPeer, "peer not available")
-}
-
-// --- FAIL: TestPEXReactorRunning (11.10s)
-// 				pex_reactor_test.go:411: expected all switches to be connected to at
-// 				least one peer (switches: 0 => {outbound: 1, inbound: 0}, 1 =>
-// 				{outbound: 0, inbound: 1}, 2 => {outbound: 0, inbound: 0}, )
-//
-// EXPLANATION: peers are getting rejected because in switch#addPeer we check
-// if any peer (who we already connected to) has the same IP. Even though local
-// peers have different IP addresses, they all have the same underlying remote
-// IP: 127.0.0.1.
-//
-func TestPEXReactorRunning(t *testing.T) {
-	N := 3
-	switches := make([]*p2p.Switch, N)
-
-	// directory to store address books
-	dir := tempDir(t)
-
-	books := make([]AddrBook, N)
-	logger := log.TestingLogger()
-
-	// create switches
-	for i := 0; i < N; i++ {
-		switches[i] = p2p.MakeSwitch(cfg, i, "testing", "123.123.123", func(i int, sw *p2p.Switch) *p2p.Switch {
-			books[i] = NewAddrBook(filepath.Join(dir, fmt.Sprintf("addrbook%d.json", i)), false)
-			books[i].SetLogger(logger.With("pex", i))
-			sw.SetAddrBook(books[i])
-
-			sw.SetLogger(logger.With("pex", i))
-
-			r := NewReactor(books[i], &ReactorConfig{})
-			r.SetLogger(logger.With("pex", i))
-			r.SetEnsurePeersPeriod(250 * time.Millisecond)
-			sw.AddReactor("pex", r)
-
-			return sw
-		}, logger)
-	}
-
-	for _, sw := range switches {
-		err := sw.Start() // start switch and reactors
-		require.Nil(t, err)
-	}
-
-	addOtherNodeAddrToAddrBook := func(switchIndex, otherSwitchIndex int) {
-		addr := switches[otherSwitchIndex].NetAddress()
-		err := books[switchIndex].AddAddress(addr, addr)
-		require.NoError(t, err)
-	}
-
-	addOtherNodeAddrToAddrBook(0, 1)
-	addOtherNodeAddrToAddrBook(1, 0)
-	addOtherNodeAddrToAddrBook(2, 1)
-
-	assertPeersWithTimeout(t, switches, 10*time.Millisecond, 10*time.Second, N-1)
-
-	// stop them
-	for _, s := range switches {
-		err := s.Stop()
-		require.NoError(t, err)
-	}
-}
-
-func TestPEXReactorReceive(t *testing.T) {
-	r, book := createReactor(t, &ReactorConfig{})
-	peer := p2p.CreateRandomPeer(false)
-
-	// we have to send a request to receive responses
-	r.RequestAddrs(peer)
-
-	size := book.Size()
-	na, err := peer.NodeInfo().NetAddress()
-	require.NoError(t, err)
-	msg := mustEncode(&tmp2p.PexResponse{Addresses: NetAddressesToProto([]*types.NetAddress{na})})
-	r.Receive(PexChannel, peer, msg)
-	assert.Equal(t, size+1, book.Size())
-
-	msg = mustEncode(&tmp2p.PexRequest{})
-	r.Receive(PexChannel, peer, msg) // should not panic.
-}
-
-func TestPEXReactorRequestMessageAbuse(t *testing.T) {
-	r, book := createReactor(t, &ReactorConfig{})
-	sw := createSwitchAndAddReactors(r)
-	sw.SetAddrBook(book)
-
-	peer := mock.NewPeer(nil)
-	peerAddr := peer.SocketAddr()
-	p2p.AddPeerToSwitchPeerSet(sw, peer)
-	assert.True(t, sw.Peers().Has(peer.ID()))
-	err := book.AddAddress(peerAddr, peerAddr)
-	require.NoError(t, err)
-	require.True(t, book.HasAddress(peerAddr))
-
-	id := string(peer.ID())
-	msg := mustEncode(&tmp2p.PexRequest{})
-
-	// first time creates the entry
-	r.Receive(PexChannel, peer, msg)
-	assert.True(t, r.lastReceivedRequests.Has(id))
-	assert.True(t, sw.Peers().Has(peer.ID()))
-
-	// next time sets the last time value
-	r.Receive(PexChannel, peer, msg)
-	assert.True(t, r.lastReceivedRequests.Has(id))
-	assert.True(t, sw.Peers().Has(peer.ID()))
-
-	// third time is too many too soon - peer is removed
-	r.Receive(PexChannel, peer, msg)
-	assert.False(t, r.lastReceivedRequests.Has(id))
-	assert.False(t, sw.Peers().Has(peer.ID()))
-	assert.True(t, book.IsBanned(peerAddr))
-}
-
-func TestPEXReactorAddrsMessageAbuse(t *testing.T) {
-	r, book := createReactor(t, &ReactorConfig{})
-	sw := createSwitchAndAddReactors(r)
-	sw.SetAddrBook(book)
-
-	peer := mock.NewPeer(nil)
-	p2p.AddPeerToSwitchPeerSet(sw, peer)
-	assert.True(t, sw.Peers().Has(peer.ID()))
-
-	id := string(peer.ID())
-
-	// request addrs from the peer
-	r.RequestAddrs(peer)
-	assert.True(t, r.requestsSent.Has(id))
-	assert.True(t, sw.Peers().Has(peer.ID()))
-
-	msg := mustEncode(&tmp2p.PexResponse{Addresses: NetAddressesToProto([]*types.NetAddress{peer.SocketAddr()})})
-
-	// receive some addrs. should clear the request
-	r.Receive(PexChannel, peer, msg)
-	assert.False(t, r.requestsSent.Has(id))
-	assert.True(t, sw.Peers().Has(peer.ID()))
-
-	// receiving more unsolicited addrs causes a disconnect and ban
-	r.Receive(PexChannel, peer, msg)
-	assert.False(t, sw.Peers().Has(peer.ID()))
-	assert.True(t, book.IsBanned(peer.SocketAddr()))
-}
-
-func TestCheckSeeds(t *testing.T) {
-	// directory to store address books
-	dir := tempDir(t)
-
-	// 1. test creating peer with no seeds works
-	peerSwitch := testCreateDefaultPeer(dir, 0)
-	require.Nil(t, peerSwitch.Start())
-	peerSwitch.Stop() // nolint:errcheck // ignore for tests
-
-	// 2. create seed
-	seed := testCreateSeed(dir, 1, []*p2p.NetAddress{}, []*p2p.NetAddress{})
-
-	// 3. test create peer with online seed works
-	peerSwitch = testCreatePeerWithSeed(dir, 2, seed)
-	require.Nil(t, peerSwitch.Start())
-	peerSwitch.Stop() // nolint:errcheck // ignore for tests
-
-	// 4. test create peer with all seeds having unresolvable DNS fails
-	badPeerConfig := &ReactorConfig{
-		Seeds: []string{"ed3dfd27bfc4af18f67a49862f04cc100696e84d@bad.network.addr:26657",
-			"d824b13cb5d40fa1d8a614e089357c7eff31b670@anotherbad.network.addr:26657"},
-	}
-	peerSwitch = testCreatePeerWithConfig(dir, 2, badPeerConfig)
-	require.Error(t, peerSwitch.Start())
-	peerSwitch.Stop() // nolint:errcheck // ignore for tests
-
-	// 5. test create peer with one good seed address succeeds
-	badPeerConfig = &ReactorConfig{
-		Seeds: []string{"ed3dfd27bfc4af18f67a49862f04cc100696e84d@bad.network.addr:26657",
-			"d824b13cb5d40fa1d8a614e089357c7eff31b670@anotherbad.network.addr:26657",
-			seed.NetAddress().String()},
-	}
-	peerSwitch = testCreatePeerWithConfig(dir, 2, badPeerConfig)
-	require.Nil(t, peerSwitch.Start())
-	peerSwitch.Stop() // nolint:errcheck // ignore for tests
-}
-
-func TestPEXReactorUsesSeedsIfNeeded(t *testing.T) {
-	// directory to store address books
-	dir := tempDir(t)
-
-	// 1. create seed
-	seed := testCreateSeed(dir, 0, []*p2p.NetAddress{}, []*p2p.NetAddress{})
-	require.Nil(t, seed.Start())
-	t.Cleanup(func() { _ = seed.Stop() })
-
-	// 2. create usual peer with only seed configured.
-	peer := testCreatePeerWithSeed(dir, 1, seed)
-	require.Nil(t, peer.Start())
-	t.Cleanup(func() { _ = peer.Stop() })
-
-	// 3. check that the peer connects to seed immediately
-	assertPeersWithTimeout(t, []*p2p.Switch{peer}, 10*time.Millisecond, 3*time.Second, 1)
-}
-
-func TestConnectionSpeedForPeerReceivedFromSeed(t *testing.T) {
-	// directory to store address books
-	dir := tempDir(t)
-
-	// 1. create peer
-	peerSwitch := testCreateDefaultPeer(dir, 1)
-	require.Nil(t, peerSwitch.Start())
-	t.Cleanup(func() { _ = peerSwitch.Stop() })
-
-	// 2. Create seed which knows about the peer
-	peerAddr := peerSwitch.NetAddress()
-	seed := testCreateSeed(dir, 2, []*p2p.NetAddress{peerAddr}, []*p2p.NetAddress{peerAddr})
-	require.Nil(t, seed.Start())
-	t.Cleanup(func() { _ = seed.Stop() })
-
-	// 3. create another peer with only seed configured.
-	secondPeer := testCreatePeerWithSeed(dir, 3, seed)
-	require.Nil(t, secondPeer.Start())
-	t.Cleanup(func() { _ = secondPeer.Stop() })
-
-	// 4. check that the second peer connects to seed immediately
-	assertPeersWithTimeout(t, []*p2p.Switch{secondPeer}, 10*time.Millisecond, 3*time.Second, 1)
-
-	// 5. check that the second peer connects to the first peer immediately
-	assertPeersWithTimeout(t, []*p2p.Switch{secondPeer}, 10*time.Millisecond, 1*time.Second, 2)
-}
-
-func TestPEXReactorSeedMode(t *testing.T) {
-	// directory to store address books
-	dir := tempDir(t)
-
-	pexRConfig := &ReactorConfig{SeedMode: true, SeedDisconnectWaitPeriod: 10 * time.Millisecond}
-	pexR, book := createReactor(t, pexRConfig)
-	sw := createSwitchAndAddReactors(pexR)
-
-	sw.SetAddrBook(book)
-	require.NoError(t, sw.Start())
-	t.Cleanup(func() { _ = sw.Stop() })
-
-	assert.Zero(t, sw.Peers().Size())
-
-	peerSwitch := testCreateDefaultPeer(dir, 1)
-	require.NoError(t, peerSwitch.Start())
-	t.Cleanup(func() { _ = peerSwitch.Stop() })
-
-	// 1. Test crawlPeers dials the peer
-	pexR.crawlPeers([]*p2p.NetAddress{peerSwitch.NetAddress()})
-	assert.Equal(t, 1, sw.Peers().Size())
-	assert.True(t, sw.Peers().Has(peerSwitch.NodeInfo().ID()))
-
-	// 2. attemptDisconnects should not disconnect because of wait period
-	pexR.attemptDisconnects()
-	assert.Equal(t, 1, sw.Peers().Size())
-
-	// sleep for SeedDisconnectWaitPeriod
-	time.Sleep(pexRConfig.SeedDisconnectWaitPeriod + 1*time.Millisecond)
-
-	// 3. attemptDisconnects should disconnect after wait period
-	pexR.attemptDisconnects()
-	assert.Equal(t, 0, sw.Peers().Size())
-}
-
-func TestPEXReactorDoesNotDisconnectFromPersistentPeerInSeedMode(t *testing.T) {
-	// directory to store address books
-	dir := tempDir(t)
-
-	pexRConfig := &ReactorConfig{SeedMode: true, SeedDisconnectWaitPeriod: 1 * time.Millisecond}
-	pexR, book := createReactor(t, pexRConfig)
-	sw := createSwitchAndAddReactors(pexR)
-
-	sw.SetAddrBook(book)
-	require.NoError(t, sw.Start())
-	t.Cleanup(func() { _ = sw.Stop() })
-
-	assert.Zero(t, sw.Peers().Size())
-
-	peerSwitch := testCreatePeerWithConfig(dir, 1, pexRConfig)
-	require.NoError(t, peerSwitch.Start())
-	t.Cleanup(func() { _ = peerSwitch.Stop() })
-
-	require.NoError(t, sw.AddPersistentPeers([]string{peerSwitch.NetAddress().String()}))
-
-	// 1. Test crawlPeers dials the peer
-	pexR.crawlPeers([]*p2p.NetAddress{peerSwitch.NetAddress()})
-	assert.Equal(t, 1, sw.Peers().Size())
-	assert.True(t, sw.Peers().Has(peerSwitch.NodeInfo().ID()))
-
-	// sleep for SeedDisconnectWaitPeriod
-	time.Sleep(pexRConfig.SeedDisconnectWaitPeriod + 1*time.Millisecond)
-
-	// 2. attemptDisconnects should not disconnect because the peer is persistent
-	pexR.attemptDisconnects()
-	assert.Equal(t, 1, sw.Peers().Size())
-}
-
-func TestPEXReactorDialsPeerUpToMaxAttemptsInSeedMode(t *testing.T) {
-	// directory to store address books
-	pexR, book := createReactor(t, &ReactorConfig{SeedMode: true})
-	sw := createSwitchAndAddReactors(pexR)
-
-	sw.SetAddrBook(book)
-	// No need to start sw since crawlPeers is called manually here.
-
-	peer := mock.NewPeer(nil)
-	addr := peer.SocketAddr()
-
-	require.NoError(t, book.AddAddress(addr, addr))
-
-	assert.True(t, book.HasAddress(addr))
-
-	// imitate maxAttemptsToDial reached
-	pexR.attemptsToDial.Store(addr.DialString(), _attemptsToDial{maxAttemptsToDial + 1, time.Now()})
-	pexR.crawlPeers([]*p2p.NetAddress{addr})
-
-	assert.False(t, book.HasAddress(addr))
-}
-
-// connect a peer to a seed, wait a bit, then stop it.
-// this should give it time to request addrs and for the seed
-// to call FlushStop, and allows us to test calling Stop concurrently
-// with FlushStop. Before a fix, this non-deterministically reproduced
-// https://github.com/tendermint/tendermint/issues/3231.
-func TestPEXReactorSeedModeFlushStop(t *testing.T) {
-	t.Skip("flaky test, will be replaced by new P2P stack")
-	N := 2
-	switches := make([]*p2p.Switch, N)
-
-	// directory to store address books
-	dir := tempDir(t)
-
-	books := make([]AddrBook, N)
-	logger := log.TestingLogger()
-
-	// create switches
-	for i := 0; i < N; i++ {
-		switches[i] = p2p.MakeSwitch(cfg, i, "testing", "123.123.123", func(i int, sw *p2p.Switch) *p2p.Switch {
-			books[i] = NewAddrBook(filepath.Join(dir, fmt.Sprintf("addrbook%d.json", i)), false)
-			books[i].SetLogger(logger.With("pex", i))
-			sw.SetAddrBook(books[i])
-
-			sw.SetLogger(logger.With("pex", i))
-
-			config := &ReactorConfig{}
-			if i == 0 {
-				// first one is a seed node
-				config = &ReactorConfig{SeedMode: true}
-			}
-			r := NewReactor(books[i], config)
-			r.SetLogger(logger.With("pex", i))
-			r.SetEnsurePeersPeriod(250 * time.Millisecond)
-			sw.AddReactor("pex", r)
-
-			return sw
-		}, logger)
-	}
-
-	for _, sw := range switches {
-		err := sw.Start() // start switch and reactors
-		require.Nil(t, err)
-	}
-
-	reactor := switches[0].Reactors()["pex"].(*Reactor)
-	peerID := switches[1].NodeInfo().ID()
-
-	assert.NoError(t, switches[1].DialPeerWithAddress(switches[0].NetAddress()))
-
-	// sleep up to a second while waiting for the peer to send us a message.
-	// this isn't perfect since it's possible the peer sends us a msg and we FlushStop
-	// before this loop catches it. but non-deterministically it works pretty well.
-	for i := 0; i < 1000; i++ {
-		v := reactor.lastReceivedRequests.Get(string(peerID))
-		if v != nil {
-			break
-		}
-		time.Sleep(time.Millisecond)
-	}
-
-	// by now the FlushStop should have happened. Try stopping the peer.
-	// it should be safe to do this.
-	peers := switches[0].Peers().List()
-	for _, peer := range peers {
-		err := peer.Stop()
-		require.NoError(t, err)
-	}
-
-	// stop the switches
-	for _, s := range switches {
-		err := s.Stop()
-		require.NoError(t, err)
-	}
-}
-
-func TestPEXReactorDoesNotAddPrivatePeersToAddrBook(t *testing.T) {
-	peer := p2p.CreateRandomPeer(false)
-
-	pexR, book := createReactor(t, &ReactorConfig{})
-	book.AddPrivateIDs([]string{string(peer.NodeInfo().ID())})
-
-	// we have to send a request to receive responses
-	pexR.RequestAddrs(peer)
-
-	size := book.Size()
-	na, err := peer.NodeInfo().NetAddress()
-	require.NoError(t, err)
-
-	msg := mustEncode(&tmp2p.PexResponse{Addresses: NetAddressesToProto([]*types.NetAddress{na})})
-	pexR.Receive(PexChannel, peer, msg)
-	assert.Equal(t, size, book.Size())
-
-	pexR.AddPeer(peer)
-	assert.Equal(t, size, book.Size())
-}
-
-func TestPEXReactorDialPeer(t *testing.T) {
-	pexR, book := createReactor(t, &ReactorConfig{})
-	sw := createSwitchAndAddReactors(pexR)
-
-	sw.SetAddrBook(book)
-
-	peer := mock.NewPeer(nil)
-	addr := peer.SocketAddr()
-
-	assert.Equal(t, 0, pexR.AttemptsToDial(addr))
-
-	// 1st unsuccessful attempt
-	err := pexR.dialPeer(addr)
-	require.Error(t, err)
-
-	assert.Equal(t, 1, pexR.AttemptsToDial(addr))
-
-	// 2nd unsuccessful attempt
-	err = pexR.dialPeer(addr)
-	require.Error(t, err)
-
-	// must be skipped because it is too early
-	assert.Equal(t, 1, pexR.AttemptsToDial(addr))
-
-	if !testing.Short() {
-		time.Sleep(3 * time.Second)
-
-		// 3rd attempt
-		err = pexR.dialPeer(addr)
-		require.Error(t, err)
-
-		assert.Equal(t, 2, pexR.AttemptsToDial(addr))
-	}
-}
-
-func assertPeersWithTimeout(
-	t *testing.T,
-	switches []*p2p.Switch,
-	checkPeriod, timeout time.Duration,
-	nPeers int,
-) {
-	var (
-		ticker    = time.NewTicker(checkPeriod)
-		remaining = timeout
-	)
-
-	for {
-		select {
-		case <-ticker.C:
-			// check peers are connected
-			allGood := true
-			for _, s := range switches {
-				outbound, inbound, _ := s.NumPeers()
-				if outbound+inbound < nPeers {
-					allGood = false
-					break
-				}
-			}
-			remaining -= checkPeriod
-			if remaining < 0 {
-				remaining = 0
-			}
-			if allGood {
-				return
-			}
-		case <-time.After(remaining):
-			numPeersStr := ""
-			for i, s := range switches {
-				outbound, inbound, _ := s.NumPeers()
-				numPeersStr += fmt.Sprintf("%d => {outbound: %d, inbound: %d}, ", i, outbound, inbound)
-			}
-			t.Errorf(
-				"expected all switches to be connected to at least %d peer(s) (switches: %s)",
-				nPeers, numPeersStr,
-			)
-			return
-		}
-	}
-}
-
-// Creates a peer with the provided config
-func testCreatePeerWithConfig(dir string, id int, config *ReactorConfig) *p2p.Switch {
-	peer := p2p.MakeSwitch(
-		cfg,
-		id,
-		"127.0.0.1",
-		"123.123.123",
-		func(i int, sw *p2p.Switch) *p2p.Switch {
-			book := NewAddrBook(filepath.Join(dir, fmt.Sprintf("addrbook%d.json", id)), false)
-			book.SetLogger(log.TestingLogger())
-			sw.SetAddrBook(book)
-
-			sw.SetLogger(log.TestingLogger())
-
-			r := NewReactor(
-				book,
-				config,
-			)
-			r.SetLogger(log.TestingLogger())
-			sw.AddReactor("pex", r)
-			return sw
-		},
-		log.TestingLogger(),
-	)
-	return peer
-}
-
-// Creates a peer with the default config
-func testCreateDefaultPeer(dir string, id int) *p2p.Switch {
-	return testCreatePeerWithConfig(dir, id, &ReactorConfig{})
-}
-
-// Creates a seed which knows about the provided addresses / source address pairs.
-// Starting and stopping the seed is left to the caller
-func testCreateSeed(dir string, id int, knownAddrs, srcAddrs []*p2p.NetAddress) *p2p.Switch {
-	seed := p2p.MakeSwitch(
-		cfg,
-		id,
-		"127.0.0.1",
-		"123.123.123",
-		func(i int, sw *p2p.Switch) *p2p.Switch {
-			book := NewAddrBook(filepath.Join(dir, "addrbookSeed.json"), false)
-			book.SetLogger(log.TestingLogger())
-			for j := 0; j < len(knownAddrs); j++ {
-				book.AddAddress(knownAddrs[j], srcAddrs[j]) // nolint:errcheck // ignore for tests
-				book.MarkGood(knownAddrs[j].ID)
-			}
-			sw.SetAddrBook(book)
-
-			sw.SetLogger(log.TestingLogger())
-
-			r := NewReactor(book, &ReactorConfig{})
-			r.SetLogger(log.TestingLogger())
-			sw.AddReactor("pex", r)
-			return sw
-		},
-		log.TestingLogger(),
-	)
-	return seed
-}
-
-// Creates a peer which knows about the provided seed.
-// Starting and stopping the peer is left to the caller
-func testCreatePeerWithSeed(dir string, id int, seed *p2p.Switch) *p2p.Switch {
-	conf := &ReactorConfig{
-		Seeds: []string{seed.NetAddress().String()},
-	}
-	return testCreatePeerWithConfig(dir, id, conf)
-}
-
-func createReactor(t *testing.T, conf *ReactorConfig) (r *Reactor, book AddrBook) {
-	// directory to store address book
-	book = NewAddrBook(filepath.Join(tempDir(t), "addrbook.json"), true)
-	book.SetLogger(log.TestingLogger())
-
-	r = NewReactor(book, conf)
-	r.SetLogger(log.TestingLogger())
-	return
-}
-
-func createSwitchAndAddReactors(reactors ...p2p.Reactor) *p2p.Switch {
-	sw := p2p.MakeSwitch(cfg, 0, "127.0.0.1", "123.123.123", func(i int, sw *p2p.Switch) *p2p.Switch {
-		for _, r := range reactors {
-			sw.AddReactor(r.String(), r)
-		}
-		return sw
-	}, log.TestingLogger())
-	return sw
-}
-
-func TestPexVectors(t *testing.T) {
-	addr := tmp2p.PexAddress{
-		ID:   "1",
-		IP:   "127.0.0.1",
-		Port: 9090,
-	}
-
-	testCases := []struct {
-		testName string
-		msg      proto.Message
-		expBytes string
-	}{
-		{"PexRequest", &tmp2p.PexRequest{}, "0a00"},
-		{"PexAddrs", &tmp2p.PexResponse{Addresses: []tmp2p.PexAddress{addr}}, "12130a110a013112093132372e302e302e31188247"},
-	}
-
-	for _, tc := range testCases {
-		tc := tc
-
-		bz := mustEncode(tc.msg)
-
-		require.Equal(t, tc.expBytes, hex.EncodeToString(bz), tc.testName)
-	}
-}
-
-// FIXME: This function is used in place of testing.TB.TempDir()
-// as the latter seems to cause test cases to fail when it is
-// unable to remove the temporary directory once  the test case
-// execution terminates. This seems to  happen often with pex
-// reactor test cases.
-//
-// References:
-// https://github.com/tendermint/tendermint/pull/5733
-// https://github.com/tendermint/tendermint/issues/5732
-func tempDir(t *testing.T) string {
-	t.Helper()
-	dir, err := ioutil.TempDir("", "")
-	require.NoError(t, err)
-	t.Cleanup(func() { _ = os.RemoveAll(dir) })
-	return dir
-}
diff --git a/internal/p2p/pex/reactor.go b/internal/p2p/pex/reactor.go
index 8cff2f95b8..300a6022dd 100644
--- a/internal/p2p/pex/reactor.go
+++ b/internal/p2p/pex/reactor.go
@@ -24,6 +24,22 @@ var (
 // TODO: Consolidate with params file.
 // See https://github.com/tendermint/tendermint/issues/6371
 const (
+	// PexChannel is a channel for PEX messages
+	PexChannel = byte(0x00)
+
+	// over-estimate of max NetAddress size
+	// hexID (40) + IP (16) + Port (2) + Name (100) ...
+	// NOTE: dont use massive DNS name ..
+	maxAddressSize = 256
+
+	// max addresses returned by GetSelection
+	// NOTE: this must match "maxMsgSize"
+	maxGetSelection = 250
+
+	// NOTE: amplification factor!
+	// small request results in up to maxMsgSize response
+	maxMsgSize = maxAddressSize * maxGetSelection
+
 	// the minimum time one peer can send another request to the same peer
 	minReceiveRequestInterval = 100 * time.Millisecond
 
diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index 1171566d14..d68f16c4f9 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -21,6 +21,8 @@ import (
 
 const queueBufferDefault = 32
 
+const dialRandomizerIntervalMillisecond = 3000
+
 // ChannelID is an arbitrary channel ID.
 type ChannelID uint16
 
@@ -544,7 +546,7 @@ func (r *Router) filterPeersID(ctx context.Context, id types.NodeID) error {
 func (r *Router) dialSleep(ctx context.Context) {
 	if r.options.DialSleep == nil {
 		// nolint:gosec // G404: Use of weak random number generator
-		timer := time.NewTimer(time.Duration(rand.Int63n(dialRandomizerIntervalMilliseconds)) * time.Millisecond)
+		timer := time.NewTimer(time.Duration(rand.Int63n(dialRandomizerIntervalMillisecond)) * time.Millisecond)
 		defer timer.Stop()
 
 		select {
diff --git a/internal/p2p/shim.go b/internal/p2p/shim.go
index 07d1ad156d..c9cdc27568 100644
--- a/internal/p2p/shim.go
+++ b/internal/p2p/shim.go
@@ -1,58 +1,42 @@
 package p2p
 
 import (
-	"errors"
 	"sort"
 
 	"github.com/gogo/protobuf/proto"
+	"github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/internal/p2p/conn"
 	"github.com/tendermint/tendermint/libs/log"
 )
 
-// ============================================================================
-// TODO: Types and business logic below are temporary and will be removed once
-// the legacy p2p stack is removed in favor of the new model.
-//
-// ref: https://github.com/tendermint/tendermint/issues/5670
-// ============================================================================
-
-var _ Reactor = (*ReactorShim)(nil)
-
-type (
-	messageValidator interface {
-		Validate() error
-	}
-
-	// ReactorShim defines a generic shim wrapper around a BaseReactor. It is
-	// responsible for wiring up legacy p2p behavior to the new p2p semantics
-	// (e.g. proxying Envelope messages to legacy peers).
-	ReactorShim struct {
-		BaseReactor
-
-		Name        string
-		PeerUpdates *PeerUpdates
-		Channels    map[ChannelID]*ChannelShim
-	}
+// ChannelDescriptorShim defines a shim wrapper around a legacy p2p channel
+// and the proto.Message the new p2p Channel is responsible for handling.
+// A ChannelDescriptorShim is not contained in ReactorShim, but is rather
+// used to construct a ReactorShim.
+type ChannelDescriptorShim struct {
+	MsgType    proto.Message
+	Descriptor *ChannelDescriptor
+}
 
-	// ChannelShim defines a generic shim wrapper around a legacy p2p channel
-	// and the new p2p Channel. It also includes the raw bi-directional Go channels
-	// so we can proxy message delivery.
-	ChannelShim struct {
-		Descriptor *ChannelDescriptor
-		Channel    *Channel
-		inCh       chan<- Envelope
-		outCh      <-chan Envelope
-		errCh      <-chan PeerError
-	}
+// ChannelShim defines a generic shim wrapper around a legacy p2p channel
+// and the new p2p Channel. It also includes the raw bi-directional Go channels
+// so we can proxy message delivery.
+type ChannelShim struct {
+	Descriptor *ChannelDescriptor
+	Channel    *Channel
+	inCh       chan<- Envelope
+	outCh      <-chan Envelope
+	errCh      <-chan PeerError
+}
 
-	// ChannelDescriptorShim defines a shim wrapper around a legacy p2p channel
-	// and the proto.Message the new p2p Channel is responsible for handling.
-	// A ChannelDescriptorShim is not contained in ReactorShim, but is rather
-	// used to construct a ReactorShim.
-	ChannelDescriptorShim struct {
-		MsgType    proto.Message
-		Descriptor *ChannelDescriptor
-	}
-)
+// ReactorShim defines a generic shim wrapper around a BaseReactor. It is
+// responsible for wiring up legacy p2p behavior to the new p2p semantics
+// (e.g. proxying Envelope messages to legacy peers).
+type ReactorShim struct {
+	Name        string
+	PeerUpdates *PeerUpdates
+	Channels    map[ChannelID]*ChannelShim
+}
 
 func NewReactorShim(logger log.Logger, name string, descriptors map[ChannelID]*ChannelDescriptorShim) *ReactorShim {
 	channels := make(map[ChannelID]*ChannelShim)
@@ -68,9 +52,6 @@ func NewReactorShim(logger log.Logger, name string, descriptors map[ChannelID]*C
 		Channels:    channels,
 	}
 
-	rs.BaseReactor = *NewBaseReactor(name, rs)
-	rs.SetLogger(logger)
-
 	return rs
 }
 
@@ -93,121 +74,15 @@ func NewChannelShim(cds *ChannelDescriptorShim, buf uint) *ChannelShim {
 	}
 }
 
-// proxyPeerEnvelopes iterates over each p2p Channel and starts a separate
-// go-routine where we listen for outbound envelopes sent during Receive
-// executions (or anything else that may send on the Channel) and proxy them to
-// the corresponding Peer using the To field from the envelope.
-func (rs *ReactorShim) proxyPeerEnvelopes() {
-	for _, cs := range rs.Channels {
-		go func(cs *ChannelShim) {
-			for e := range cs.outCh {
-				msg := proto.Clone(cs.Channel.messageType)
-				msg.Reset()
-
-				wrapper, ok := msg.(Wrapper)
-				if ok {
-					if err := wrapper.Wrap(e.Message); err != nil {
-						rs.Logger.Error(
-							"failed to proxy envelope; failed to wrap message",
-							"ch_id", cs.Descriptor.ID,
-							"err", err,
-						)
-						continue
-					}
-				} else {
-					msg = e.Message
-				}
-
-				bz, err := proto.Marshal(msg)
-				if err != nil {
-					rs.Logger.Error(
-						"failed to proxy envelope; failed to encode message",
-						"ch_id", cs.Descriptor.ID,
-						"err", err,
-					)
-					continue
-				}
-
-				switch {
-				case e.Broadcast:
-					rs.Switch.Broadcast(cs.Descriptor.ID, bz)
-
-				case e.To != "":
-					src := rs.Switch.peers.Get(e.To)
-					if src == nil {
-						rs.Logger.Debug(
-							"failed to proxy envelope; failed to find peer",
-							"ch_id", cs.Descriptor.ID,
-							"peer", e.To,
-						)
-						continue
-					}
-
-					if !src.Send(cs.Descriptor.ID, bz) {
-						// This usually happens when we try to send across a channel
-						// that the peer doesn't have open. To avoid bloating the
-						// logs we set this to be Debug
-						rs.Logger.Debug(
-							"failed to proxy message to peer",
-							"ch_id", cs.Descriptor.ID,
-							"peer", e.To,
-						)
-					}
-
-				default:
-					rs.Logger.Error("failed to proxy envelope; missing peer ID", "ch_id", cs.Descriptor.ID)
-				}
-			}
-		}(cs)
-	}
-}
-
-// handlePeerErrors iterates over each p2p Channel and starts a separate go-routine
-// where we listen for peer errors. For each peer error, we find the peer from
-// the legacy p2p Switch and execute a StopPeerForError call with the corresponding
-// peer error.
-func (rs *ReactorShim) handlePeerErrors() {
-	for _, cs := range rs.Channels {
-		go func(cs *ChannelShim) {
-			for pErr := range cs.errCh {
-				if pErr.NodeID != "" {
-					peer := rs.Switch.peers.Get(pErr.NodeID)
-					if peer == nil {
-						rs.Logger.Error("failed to handle peer error; failed to find peer", "peer", pErr.NodeID)
-						continue
-					}
-
-					rs.Switch.StopPeerForError(peer, pErr.Err)
-				}
-			}
-		}(cs)
-	}
-}
-
-// OnStart executes the reactor shim's OnStart hook where we start all the
-// necessary go-routines in order to proxy peer envelopes and errors per p2p
-// Channel.
-func (rs *ReactorShim) OnStart() error {
-	if rs.Switch == nil {
-		return errors.New("proxyPeerEnvelopes: reactor shim switch is nil")
-	}
-
-	// start envelope proxying and peer error handling in separate go routines
-	rs.proxyPeerEnvelopes()
-	rs.handlePeerErrors()
-
-	return nil
-}
-
-// GetChannel returns a p2p Channel reference for a given ChannelID. If no
-// Channel exists, nil is returned.
-func (rs *ReactorShim) GetChannel(cID ChannelID) *Channel {
-	channelShim, ok := rs.Channels[cID]
-	if ok {
-		return channelShim.Channel
-	}
-
-	return nil
+// MConnConfig returns an MConnConfig based on the defaults, with fields updated
+// from the P2PConfig.
+func MConnConfig(cfg *config.P2PConfig) conn.MConnConfig {
+	mConfig := conn.DefaultMConnConfig()
+	mConfig.FlushThrottle = cfg.FlushThrottleTimeout
+	mConfig.SendRate = cfg.SendRate
+	mConfig.RecvRate = cfg.RecvRate
+	mConfig.MaxPacketMsgPayloadSize = cfg.MaxPacketMsgPayloadSize
+	return mConfig
 }
 
 // GetChannels implements the legacy Reactor interface for getting a slice of all
@@ -228,107 +103,13 @@ func (rs *ReactorShim) GetChannels() []*ChannelDescriptor {
 	return descriptors
 }
 
-// AddPeer sends a PeerUpdate with status PeerStatusUp on the PeerUpdateCh.
-// The embedding reactor must be sure to listen for messages on this channel to
-// handle adding a peer.
-func (rs *ReactorShim) AddPeer(peer Peer) {
-	select {
-	case rs.PeerUpdates.reactorUpdatesCh <- PeerUpdate{NodeID: peer.ID(), Status: PeerStatusUp}:
-		rs.Logger.Debug("sent peer update", "reactor", rs.Name, "peer", peer.ID(), "status", PeerStatusUp)
-
-	case <-rs.PeerUpdates.Done():
-		// NOTE: We explicitly DO NOT close the PeerUpdatesCh's updateCh go channel.
-		// This is because there may be numerous spawned goroutines that are
-		// attempting to send on the updateCh go channel and when the reactor stops
-		// we do not want to preemptively close the channel as that could result in
-		// panics sending on a closed channel. This also means that reactors MUST
-		// be certain there are NO listeners on the updateCh channel when closing or
-		// stopping.
-	}
-}
-
-// RemovePeer sends a PeerUpdate with status PeerStatusDown on the PeerUpdateCh.
-// The embedding reactor must be sure to listen for messages on this channel to
-// handle removing a peer.
-func (rs *ReactorShim) RemovePeer(peer Peer, reason interface{}) {
-	select {
-	case rs.PeerUpdates.reactorUpdatesCh <- PeerUpdate{NodeID: peer.ID(), Status: PeerStatusDown}:
-		rs.Logger.Debug(
-			"sent peer update",
-			"reactor", rs.Name,
-			"peer", peer.ID(),
-			"reason", reason,
-			"status", PeerStatusDown,
-		)
-
-	case <-rs.PeerUpdates.Done():
-		// NOTE: We explicitly DO NOT close the PeerUpdatesCh's updateCh go channel.
-		// This is because there may be numerous spawned goroutines that are
-		// attempting to send on the updateCh go channel and when the reactor stops
-		// we do not want to preemptively close the channel as that could result in
-		// panics sending on a closed channel. This also means that reactors MUST
-		// be certain there are NO listeners on the updateCh channel when closing or
-		// stopping.
-	}
-}
-
-// Receive implements a generic wrapper around implementing the Receive method
-// on the legacy Reactor p2p interface. If the reactor is running, Receive will
-// find the corresponding new p2p Channel, create and decode the appropriate
-// proto.Message from the msgBytes, execute any validation and finally construct
-// and send a p2p Envelope on the appropriate p2p Channel.
-func (rs *ReactorShim) Receive(chID byte, src Peer, msgBytes []byte) {
-	if !rs.IsRunning() {
-		return
-	}
-
-	cID := ChannelID(chID)
+// GetChannel returns a p2p Channel reference for a given ChannelID. If no
+// Channel exists, nil is returned.
+func (rs *ReactorShim) GetChannel(cID ChannelID) *Channel {
 	channelShim, ok := rs.Channels[cID]
-	if !ok {
-		rs.Logger.Error("unexpected channel", "peer", src, "ch_id", chID)
-		return
-	}
-
-	msg := proto.Clone(channelShim.Channel.messageType)
-	msg.Reset()
-
-	if err := proto.Unmarshal(msgBytes, msg); err != nil {
-		rs.Logger.Error("error decoding message", "peer", src, "ch_id", cID, "err", err)
-		rs.Switch.StopPeerForError(src, err)
-		return
-	}
-
-	validator, ok := msg.(messageValidator)
 	if ok {
-		if err := validator.Validate(); err != nil {
-			rs.Logger.Error("invalid message", "peer", src, "ch_id", cID, "err", err)
-			rs.Switch.StopPeerForError(src, err)
-			return
-		}
-	}
-
-	wrapper, ok := msg.(Wrapper)
-	if ok {
-		var err error
-
-		msg, err = wrapper.Unwrap()
-		if err != nil {
-			rs.Logger.Error("failed to unwrap message", "peer", src, "ch_id", chID, "err", err)
-			return
-		}
+		return channelShim.Channel
 	}
 
-	select {
-	case channelShim.inCh <- Envelope{From: src.ID(), Message: msg}:
-		rs.Logger.Debug("proxied envelope", "reactor", rs.Name, "ch_id", cID, "peer", src.ID())
-
-	case <-channelShim.Channel.Done():
-		// NOTE: We explicitly DO NOT close the p2p Channel's inbound go channel.
-		// This is because there may be numerous spawned goroutines that are
-		// attempting to send on the inbound channel and when the reactor stops we
-		// do not want to preemptively close the channel as that could result in
-		// panics sending on a closed channel. This also means that reactors MUST
-		// be certain there are NO listeners on the inbound channel when closing or
-		// stopping.
-	}
+	return nil
 }
diff --git a/internal/p2p/shim_test.go b/internal/p2p/shim_test.go
deleted file mode 100644
index d8b9e30c3b..0000000000
--- a/internal/p2p/shim_test.go
+++ /dev/null
@@ -1,207 +0,0 @@
-package p2p_test
-
-import (
-	"sync"
-	"testing"
-
-	"github.com/gogo/protobuf/proto"
-	"github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/require"
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/p2p"
-	p2pmocks "github.com/tendermint/tendermint/internal/p2p/mocks"
-	"github.com/tendermint/tendermint/libs/log"
-	ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync"
-	"github.com/tendermint/tendermint/types"
-)
-
-var (
-	channelID1 = byte(0x01)
-	channelID2 = byte(0x02)
-
-	p2pCfg = config.DefaultP2PConfig()
-
-	testChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
-		p2p.ChannelID(channelID1): {
-			MsgType: new(ssproto.Message),
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  channelID1,
-				Priority:            3,
-				SendQueueCapacity:   10,
-				RecvMessageCapacity: int(4e6),
-			},
-		},
-		p2p.ChannelID(channelID2): {
-			MsgType: new(ssproto.Message),
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  channelID2,
-				Priority:            1,
-				SendQueueCapacity:   4,
-				RecvMessageCapacity: int(16e6),
-			},
-		},
-	}
-)
-
-type reactorShimTestSuite struct {
-	shim *p2p.ReactorShim
-	sw   *p2p.Switch
-}
-
-func setup(t *testing.T, peers []p2p.Peer) *reactorShimTestSuite {
-	t.Helper()
-
-	rts := &reactorShimTestSuite{
-		shim: p2p.NewReactorShim(log.TestingLogger(), "TestShim", testChannelShims),
-	}
-
-	rts.sw = p2p.MakeSwitch(p2pCfg, 1, "testing", "123.123.123", func(_ int, sw *p2p.Switch) *p2p.Switch {
-		for _, peer := range peers {
-			p2p.AddPeerToSwitchPeerSet(sw, peer)
-		}
-
-		sw.AddReactor(rts.shim.Name, rts.shim)
-		return sw
-	}, log.TestingLogger())
-
-	// start the reactor shim
-	require.NoError(t, rts.shim.Start())
-
-	t.Cleanup(func() {
-		require.NoError(t, rts.shim.Stop())
-
-		for _, chs := range rts.shim.Channels {
-			chs.Channel.Close()
-		}
-	})
-
-	return rts
-}
-
-func simplePeer(t *testing.T, id string) (*p2pmocks.Peer, types.NodeID) {
-	t.Helper()
-
-	peerID := types.NodeID(id)
-	peer := &p2pmocks.Peer{}
-	peer.On("ID").Return(peerID)
-
-	return peer, peerID
-}
-
-func TestReactorShim_GetChannel(t *testing.T) {
-	rts := setup(t, nil)
-
-	p2pCh := rts.shim.GetChannel(p2p.ChannelID(channelID1))
-	require.NotNil(t, p2pCh)
-	require.Equal(t, p2pCh.ID, p2p.ChannelID(channelID1))
-
-	p2pCh = rts.shim.GetChannel(p2p.ChannelID(byte(0x03)))
-	require.Nil(t, p2pCh)
-}
-
-func TestReactorShim_GetChannels(t *testing.T) {
-	rts := setup(t, nil)
-
-	p2pChs := rts.shim.GetChannels()
-	require.Len(t, p2pChs, 2)
-	require.Equal(t, p2p.ChannelID(p2pChs[0].ID), p2p.ChannelID(channelID1))
-	require.Equal(t, p2p.ChannelID(p2pChs[1].ID), p2p.ChannelID(channelID2))
-}
-
-func TestReactorShim_AddPeer(t *testing.T) {
-	peerA, peerIDA := simplePeer(t, "aa")
-	rts := setup(t, []p2p.Peer{peerA})
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-
-	var peerUpdate p2p.PeerUpdate
-	go func() {
-		peerUpdate = <-rts.shim.PeerUpdates.Updates()
-		wg.Done()
-	}()
-
-	rts.shim.AddPeer(peerA)
-	wg.Wait()
-
-	require.Equal(t, peerIDA, peerUpdate.NodeID)
-	require.Equal(t, p2p.PeerStatusUp, peerUpdate.Status)
-}
-
-func TestReactorShim_RemovePeer(t *testing.T) {
-	peerA, peerIDA := simplePeer(t, "aa")
-	rts := setup(t, []p2p.Peer{peerA})
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-
-	var peerUpdate p2p.PeerUpdate
-	go func() {
-		peerUpdate = <-rts.shim.PeerUpdates.Updates()
-		wg.Done()
-	}()
-
-	rts.shim.RemovePeer(peerA, "test reason")
-	wg.Wait()
-
-	require.Equal(t, peerIDA, peerUpdate.NodeID)
-	require.Equal(t, p2p.PeerStatusDown, peerUpdate.Status)
-}
-
-func TestReactorShim_Receive(t *testing.T) {
-	peerA, peerIDA := simplePeer(t, "aa")
-	rts := setup(t, []p2p.Peer{peerA})
-
-	msg := &ssproto.Message{
-		Sum: &ssproto.Message_ChunkRequest{
-			ChunkRequest: &ssproto.ChunkRequest{Height: 1, Format: 1, Index: 1},
-		},
-	}
-
-	bz, err := proto.Marshal(msg)
-	require.NoError(t, err)
-
-	var wg sync.WaitGroup
-
-	var response *ssproto.Message
-	peerA.On("Send", channelID1, mock.Anything).Run(func(args mock.Arguments) {
-		m := &ssproto.Message{}
-		require.NoError(t, proto.Unmarshal(args[1].([]byte), m))
-
-		response = m
-		wg.Done()
-	}).Return(true)
-
-	p2pCh := rts.shim.Channels[p2p.ChannelID(channelID1)]
-
-	wg.Add(2)
-
-	// Simulate receiving the envelope in some real reactor and replying back with
-	// the same envelope and then closing the Channel.
-	go func() {
-		e := <-p2pCh.Channel.In
-		require.Equal(t, peerIDA, e.From)
-		require.NotNil(t, e.Message)
-
-		p2pCh.Channel.Out <- p2p.Envelope{To: e.From, Message: e.Message}
-		p2pCh.Channel.Close()
-		wg.Done()
-	}()
-
-	rts.shim.Receive(channelID1, peerA, bz)
-
-	// wait until the mock peer called Send and we (fake) proxied the envelope
-	wg.Wait()
-	require.NotNil(t, response)
-
-	m, err := response.Unwrap()
-	require.NoError(t, err)
-	require.Equal(t, msg.GetChunkRequest(), m)
-
-	// Since p2pCh was closed in the simulated reactor above, calling Receive
-	// should not block.
-	rts.shim.Receive(channelID1, peerA, bz)
-	require.Empty(t, p2pCh.Channel.In)
-
-	peerA.AssertExpectations(t)
-}
diff --git a/internal/p2p/switch.go b/internal/p2p/switch.go
deleted file mode 100644
index ea1272354e..0000000000
--- a/internal/p2p/switch.go
+++ /dev/null
@@ -1,1064 +0,0 @@
-package p2p
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math"
-	mrand "math/rand"
-	"net"
-	"sync"
-	"time"
-
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
-	"github.com/tendermint/tendermint/libs/cmap"
-	tmrand "github.com/tendermint/tendermint/libs/rand"
-	"github.com/tendermint/tendermint/libs/service"
-	"github.com/tendermint/tendermint/types"
-)
-
-const (
-	// wait a random amount of time from this interval
-	// before dialing peers or reconnecting to help prevent DoS
-	dialRandomizerIntervalMilliseconds = 3000
-
-	// repeatedly try to reconnect for a few minutes
-	// ie. 5 * 20 = 100s
-	reconnectAttempts = 20
-	reconnectInterval = 5 * time.Second
-
-	// then move into exponential backoff mode for ~1day
-	// ie. 3**10 = 16hrs
-	reconnectBackOffAttempts    = 10
-	reconnectBackOffBaseSeconds = 3
-
-	defaultFilterTimeout = 5 * time.Second
-)
-
-// MConnConfig returns an MConnConfig with fields updated
-// from the P2PConfig.
-func MConnConfig(cfg *config.P2PConfig) conn.MConnConfig {
-	mConfig := conn.DefaultMConnConfig()
-	mConfig.FlushThrottle = cfg.FlushThrottleTimeout
-	mConfig.SendRate = cfg.SendRate
-	mConfig.RecvRate = cfg.RecvRate
-	mConfig.MaxPacketMsgPayloadSize = cfg.MaxPacketMsgPayloadSize
-	return mConfig
-}
-
-//-----------------------------------------------------------------------------
-
-// An AddrBook represents an address book from the pex package, which is used
-// to store peer addresses.
-type AddrBook interface {
-	AddAddress(addr *NetAddress, src *NetAddress) error
-	AddPrivateIDs([]string)
-	AddOurAddress(*NetAddress)
-	OurAddress(*NetAddress) bool
-	MarkGood(types.NodeID)
-	RemoveAddress(*NetAddress)
-	HasAddress(*NetAddress) bool
-	Save()
-}
-
-// ConnFilterFunc is a callback for connection filtering. If it returns an
-// error, the connection is rejected. The set of existing connections is passed
-// along with the new connection and all resolved IPs.
-type ConnFilterFunc func(ConnSet, net.Conn, []net.IP) error
-
-// PeerFilterFunc to be implemented by filter hooks after a new Peer has been
-// fully setup.
-type PeerFilterFunc func(IPeerSet, Peer) error
-
-// ConnDuplicateIPFilter resolves and keeps all ips for an incoming connection
-// and refuses new ones if they come from a known ip.
-var ConnDuplicateIPFilter ConnFilterFunc = func(cs ConnSet, c net.Conn, ips []net.IP) error {
-	for _, ip := range ips {
-		if cs.HasIP(ip) {
-			return ErrRejected{
-				conn:        c,
-				err:         fmt.Errorf("ip<%v> already connected", ip),
-				isDuplicate: true,
-			}
-		}
-	}
-	return nil
-}
-
-//-----------------------------------------------------------------------------
-
-// Switch handles peer connections and exposes an API to receive incoming messages
-// on `Reactors`.  Each `Reactor` is responsible for handling incoming messages of one
-// or more `Channels`.  So while sending outgoing messages is typically performed on the peer,
-// incoming messages are received on the reactor.
-type Switch struct {
-	service.BaseService
-
-	config       *config.P2PConfig
-	reactors     map[string]Reactor
-	chDescs      []*conn.ChannelDescriptor
-	reactorsByCh map[byte]Reactor
-	peers        *PeerSet
-	dialing      *cmap.CMap
-	reconnecting *cmap.CMap
-	nodeInfo     types.NodeInfo // our node info
-	nodeKey      types.NodeKey  // our node privkey
-	addrBook     AddrBook
-	// peers addresses with whom we'll maintain constant connection
-	persistentPeersAddrs []*NetAddress
-	unconditionalPeerIDs map[types.NodeID]struct{}
-
-	transport Transport
-
-	filterTimeout time.Duration
-	peerFilters   []PeerFilterFunc
-	connFilters   []ConnFilterFunc
-	conns         ConnSet
-
-	metrics *Metrics
-}
-
-// NetAddress returns the first address the switch is listening on,
-// or nil if no addresses are found.
-func (sw *Switch) NetAddress() *NetAddress {
-	endpoints := sw.transport.Endpoints()
-	if len(endpoints) == 0 {
-		return nil
-	}
-	return &NetAddress{
-		ID:   sw.nodeInfo.NodeID,
-		IP:   endpoints[0].IP,
-		Port: endpoints[0].Port,
-	}
-}
-
-// SwitchOption sets an optional parameter on the Switch.
-type SwitchOption func(*Switch)
-
-// NewSwitch creates a new Switch with the given config.
-func NewSwitch(
-	cfg *config.P2PConfig,
-	transport Transport,
-	options ...SwitchOption,
-) *Switch {
-	sw := &Switch{
-		config:               cfg,
-		reactors:             make(map[string]Reactor),
-		chDescs:              make([]*conn.ChannelDescriptor, 0),
-		reactorsByCh:         make(map[byte]Reactor),
-		peers:                NewPeerSet(),
-		dialing:              cmap.NewCMap(),
-		reconnecting:         cmap.NewCMap(),
-		metrics:              NopMetrics(),
-		transport:            transport,
-		persistentPeersAddrs: make([]*NetAddress, 0),
-		unconditionalPeerIDs: make(map[types.NodeID]struct{}),
-		filterTimeout:        defaultFilterTimeout,
-		conns:                NewConnSet(),
-	}
-
-	// Ensure PRNG is reseeded.
-	tmrand.Reseed()
-
-	sw.BaseService = *service.NewBaseService(nil, "P2P Switch", sw)
-
-	for _, option := range options {
-		option(sw)
-	}
-
-	return sw
-}
-
-// SwitchFilterTimeout sets the timeout used for peer filters.
-func SwitchFilterTimeout(timeout time.Duration) SwitchOption {
-	return func(sw *Switch) { sw.filterTimeout = timeout }
-}
-
-// SwitchPeerFilters sets the filters for rejection of new peers.
-func SwitchPeerFilters(filters ...PeerFilterFunc) SwitchOption {
-	return func(sw *Switch) { sw.peerFilters = filters }
-}
-
-// SwitchConnFilters sets the filters for rejection of connections.
-func SwitchConnFilters(filters ...ConnFilterFunc) SwitchOption {
-	return func(sw *Switch) { sw.connFilters = filters }
-}
-
-// WithMetrics sets the metrics.
-func WithMetrics(metrics *Metrics) SwitchOption {
-	return func(sw *Switch) { sw.metrics = metrics }
-}
-
-//---------------------------------------------------------------------
-// Switch setup
-
-// AddReactor adds the given reactor to the switch.
-// NOTE: Not goroutine safe.
-func (sw *Switch) AddReactor(name string, reactor Reactor) Reactor {
-	for _, chDesc := range reactor.GetChannels() {
-		chID := chDesc.ID
-		// No two reactors can share the same channel.
-		if sw.reactorsByCh[chID] != nil {
-			panic(fmt.Sprintf("Channel %X has multiple reactors %v & %v", chID, sw.reactorsByCh[chID], reactor))
-		}
-		sw.chDescs = append(sw.chDescs, chDesc)
-		sw.reactorsByCh[chID] = reactor
-	}
-	sw.reactors[name] = reactor
-	reactor.SetSwitch(sw)
-	return reactor
-}
-
-// RemoveReactor removes the given Reactor from the Switch.
-// NOTE: Not goroutine safe.
-func (sw *Switch) RemoveReactor(name string, reactor Reactor) {
-	for _, chDesc := range reactor.GetChannels() {
-		// remove channel description
-		for i := 0; i < len(sw.chDescs); i++ {
-			if chDesc.ID == sw.chDescs[i].ID {
-				sw.chDescs = append(sw.chDescs[:i], sw.chDescs[i+1:]...)
-				break
-			}
-		}
-		delete(sw.reactorsByCh, chDesc.ID)
-	}
-	delete(sw.reactors, name)
-	reactor.SetSwitch(nil)
-}
-
-// Reactors returns a map of reactors registered on the switch.
-// NOTE: Not goroutine safe.
-func (sw *Switch) Reactors() map[string]Reactor {
-	return sw.reactors
-}
-
-// Reactor returns the reactor with the given name.
-// NOTE: Not goroutine safe.
-func (sw *Switch) Reactor(name string) Reactor {
-	return sw.reactors[name]
-}
-
-// SetNodeInfo sets the switch's NodeInfo for checking compatibility and handshaking with other nodes.
-// NOTE: Not goroutine safe.
-func (sw *Switch) SetNodeInfo(nodeInfo types.NodeInfo) {
-	sw.nodeInfo = nodeInfo
-}
-
-// NodeInfo returns the switch's NodeInfo.
-// NOTE: Not goroutine safe.
-func (sw *Switch) NodeInfo() types.NodeInfo {
-	return sw.nodeInfo
-}
-
-// SetNodeKey sets the switch's private key for authenticated encryption.
-// NOTE: Not goroutine safe.
-func (sw *Switch) SetNodeKey(nodeKey types.NodeKey) {
-	sw.nodeKey = nodeKey
-}
-
-//---------------------------------------------------------------------
-// Service start/stop
-
-// OnStart implements BaseService. It starts all the reactors and peers.
-func (sw *Switch) OnStart() error {
-
-	// FIXME: Temporary hack to pass channel descriptors to MConn transport,
-	// since they are not available when it is constructed. This will be
-	// fixed when we implement the new router abstraction.
-	if t, ok := sw.transport.(*MConnTransport); ok {
-		t.channelDescs = sw.chDescs
-	}
-
-	// Start reactors
-	for _, reactor := range sw.reactors {
-		err := reactor.Start()
-		if err != nil {
-			return fmt.Errorf("failed to start %v: %w", reactor, err)
-		}
-	}
-
-	// Start accepting Peers.
-	go sw.acceptRoutine()
-
-	return nil
-}
-
-// OnStop implements BaseService. It stops all peers and reactors.
-func (sw *Switch) OnStop() {
-	// Stop peers
-	for _, p := range sw.peers.List() {
-		sw.stopAndRemovePeer(p, nil)
-	}
-
-	// Stop reactors
-	sw.Logger.Debug("Switch: Stopping reactors")
-	for _, reactor := range sw.reactors {
-		if err := reactor.Stop(); err != nil {
-			sw.Logger.Error("error while stopping reactor", "reactor", reactor, "error", err)
-		}
-	}
-}
-
-//---------------------------------------------------------------------
-// Peers
-
-// Broadcast runs a go routine for each attempted send, which will block trying
-// to send for defaultSendTimeoutSeconds. Returns a channel which receives
-// success values for each attempted send (false if times out). Channel will be
-// closed once msg bytes are sent to all peers (or time out).
-//
-// NOTE: Broadcast uses goroutines, so order of broadcast may not be preserved.
-func (sw *Switch) Broadcast(chID byte, msgBytes []byte) chan bool {
-	sw.Logger.Debug("Broadcast", "channel", chID, "msgBytes", msgBytes)
-
-	peers := sw.peers.List()
-	var wg sync.WaitGroup
-	wg.Add(len(peers))
-	successChan := make(chan bool, len(peers))
-
-	for _, peer := range peers {
-		go func(p Peer) {
-			defer wg.Done()
-			success := p.Send(chID, msgBytes)
-			successChan <- success
-		}(peer)
-	}
-
-	go func() {
-		wg.Wait()
-		close(successChan)
-	}()
-
-	return successChan
-}
-
-// NumPeers returns the count of outbound/inbound and outbound-dialing peers.
-// unconditional peers are not counted here.
-func (sw *Switch) NumPeers() (outbound, inbound, dialing int) {
-	peers := sw.peers.List()
-	for _, peer := range peers {
-		if peer.IsOutbound() {
-			if !sw.IsPeerUnconditional(peer.ID()) {
-				outbound++
-			}
-		} else {
-			if !sw.IsPeerUnconditional(peer.ID()) {
-				inbound++
-			}
-		}
-	}
-	dialing = sw.dialing.Size()
-	return
-}
-
-func (sw *Switch) IsPeerUnconditional(id types.NodeID) bool {
-	_, ok := sw.unconditionalPeerIDs[id]
-	return ok
-}
-
-// MaxNumOutboundPeers returns a maximum number of outbound peers.
-func (sw *Switch) MaxNumOutboundPeers() int {
-	return sw.config.MaxNumOutboundPeers
-}
-
-// Peers returns the set of peers that are connected to the switch.
-func (sw *Switch) Peers() IPeerSet {
-	return sw.peers
-}
-
-// StopPeerForError disconnects from a peer due to external error.
-// If the peer is persistent, it will attempt to reconnect.
-// TODO: make record depending on reason.
-func (sw *Switch) StopPeerForError(peer Peer, reason interface{}) {
-	if !peer.IsRunning() {
-		return
-	}
-
-	sw.Logger.Error("Stopping peer for error", "peer", peer, "err", reason)
-	sw.stopAndRemovePeer(peer, reason)
-
-	if peer.IsPersistent() {
-		var addr *NetAddress
-		if peer.IsOutbound() { // socket address for outbound peers
-			addr = peer.SocketAddr()
-		} else { // self-reported address for inbound peers
-			var err error
-			addr, err = peer.NodeInfo().NetAddress()
-			if err != nil {
-				sw.Logger.Error("Wanted to reconnect to inbound peer, but self-reported address is wrong",
-					"peer", peer, "err", err)
-				return
-			}
-		}
-		go sw.reconnectToPeer(addr)
-	}
-}
-
-// StopPeerGracefully disconnects from a peer gracefully.
-// TODO: handle graceful disconnects.
-func (sw *Switch) StopPeerGracefully(peer Peer) {
-	sw.Logger.Info("Stopping peer gracefully")
-	sw.stopAndRemovePeer(peer, nil)
-}
-
-func (sw *Switch) stopAndRemovePeer(peer Peer, reason interface{}) {
-	if err := peer.Stop(); err != nil {
-		sw.Logger.Error("error while stopping peer", "error", err) // TODO: should return error to be handled accordingly
-	}
-
-	for _, reactor := range sw.reactors {
-		reactor.RemovePeer(peer, reason)
-	}
-
-	// Removing a peer should go last to avoid a situation where a peer
-	// reconnect to our node and the switch calls InitPeer before
-	// RemovePeer is finished.
-	// https://github.com/tendermint/tendermint/issues/3338
-	if sw.peers.Remove(peer) {
-		sw.metrics.Peers.Add(float64(-1))
-	}
-
-	sw.conns.RemoveAddr(peer.RemoteAddr())
-}
-
-// reconnectToPeer tries to reconnect to the addr, first repeatedly
-// with a fixed interval, then with exponential backoff.
-// If no success after all that, it stops trying, and leaves it
-// to the PEX/Addrbook to find the peer with the addr again
-// NOTE: this will keep trying even if the handshake or auth fails.
-// TODO: be more explicit with error types so we only retry on certain failures
-//  - ie. if we're getting ErrDuplicatePeer we can stop
-//  	because the addrbook got us the peer back already
-func (sw *Switch) reconnectToPeer(addr *NetAddress) {
-	if _, exists := sw.reconnecting.GetOrSet(string(addr.ID), addr); exists {
-		return
-	}
-	defer sw.reconnecting.Delete(string(addr.ID))
-
-	start := time.Now()
-	sw.Logger.Info("Reconnecting to peer", "addr", addr)
-	for i := 0; i < reconnectAttempts; i++ {
-		if !sw.IsRunning() {
-			return
-		}
-
-		err := sw.DialPeerWithAddress(addr)
-		if err == nil {
-			return // success
-		} else if _, ok := err.(ErrCurrentlyDialingOrExistingAddress); ok {
-			return
-		}
-
-		sw.Logger.Info("Error reconnecting to peer. Trying again", "tries", i, "err", err, "addr", addr)
-		// sleep a set amount
-		sw.randomSleep(reconnectInterval)
-		continue
-	}
-
-	sw.Logger.Error("Failed to reconnect to peer. Beginning exponential backoff",
-		"addr", addr, "elapsed", time.Since(start))
-	for i := 0; i < reconnectBackOffAttempts; i++ {
-		if !sw.IsRunning() {
-			return
-		}
-
-		// sleep an exponentially increasing amount
-		sleepIntervalSeconds := math.Pow(reconnectBackOffBaseSeconds, float64(i))
-		sw.randomSleep(time.Duration(sleepIntervalSeconds) * time.Second)
-
-		err := sw.DialPeerWithAddress(addr)
-		if err == nil {
-			return // success
-		} else if _, ok := err.(ErrCurrentlyDialingOrExistingAddress); ok {
-			return
-		}
-		sw.Logger.Info("Error reconnecting to peer. Trying again", "tries", i, "err", err, "addr", addr)
-	}
-	sw.Logger.Error("Failed to reconnect to peer. Giving up", "addr", addr, "elapsed", time.Since(start))
-}
-
-// SetAddrBook allows to set address book on Switch.
-func (sw *Switch) SetAddrBook(addrBook AddrBook) {
-	sw.addrBook = addrBook
-}
-
-// MarkPeerAsGood marks the given peer as good when it did something useful
-// like contributed to consensus.
-func (sw *Switch) MarkPeerAsGood(peer Peer) {
-	if sw.addrBook != nil {
-		sw.addrBook.MarkGood(peer.ID())
-	}
-}
-
-//---------------------------------------------------------------------
-// Dialing
-
-type privateAddr interface {
-	PrivateAddr() bool
-}
-
-func isPrivateAddr(err error) bool {
-	te, ok := err.(privateAddr)
-	return ok && te.PrivateAddr()
-}
-
-// DialPeersAsync dials a list of peers asynchronously in random order.
-// Used to dial peers from config on startup or from unsafe-RPC (trusted sources).
-// It ignores ErrNetAddressLookup. However, if there are other errors, first
-// encounter is returned.
-// Nop if there are no peers.
-func (sw *Switch) DialPeersAsync(peers []string) error {
-	netAddrs, errs := NewNetAddressStrings(peers)
-	// report all the errors
-	for _, err := range errs {
-		sw.Logger.Error("Error in peer's address", "err", err)
-	}
-	// return first non-ErrNetAddressLookup error
-	for _, err := range errs {
-		if _, ok := err.(types.ErrNetAddressLookup); ok {
-			continue
-		}
-		return err
-	}
-	sw.dialPeersAsync(netAddrs)
-	return nil
-}
-
-func (sw *Switch) dialPeersAsync(netAddrs []*NetAddress) {
-	ourAddr := sw.NetAddress()
-
-	// TODO: this code feels like it's in the wrong place.
-	// The integration tests depend on the addrBook being saved
-	// right away but maybe we can change that. Recall that
-	// the addrBook is only written to disk every 2min
-	if sw.addrBook != nil {
-		// add peers to `addrBook`
-		for _, netAddr := range netAddrs {
-			// do not add our address or ID
-			if !netAddr.Same(ourAddr) {
-				if err := sw.addrBook.AddAddress(netAddr, ourAddr); err != nil {
-					if isPrivateAddr(err) {
-						sw.Logger.Debug("Won't add peer's address to addrbook", "err", err)
-					} else {
-						sw.Logger.Error("Can't add peer's address to addrbook", "err", err)
-					}
-				}
-			}
-		}
-		// Persist some peers to disk right away.
-		// NOTE: integration tests depend on this
-		sw.addrBook.Save()
-	}
-
-	// permute the list, dial them in random order.
-	perm := mrand.Perm(len(netAddrs))
-	for i := 0; i < len(perm); i++ {
-		go func(i int) {
-			j := perm[i]
-			addr := netAddrs[j]
-
-			if addr.Same(ourAddr) {
-				sw.Logger.Debug("Ignore attempt to connect to ourselves", "addr", addr, "ourAddr", ourAddr)
-				return
-			}
-
-			sw.randomSleep(0)
-
-			err := sw.DialPeerWithAddress(addr)
-			if err != nil {
-				switch err.(type) {
-				case ErrSwitchConnectToSelf, ErrSwitchDuplicatePeerID, ErrCurrentlyDialingOrExistingAddress:
-					sw.Logger.Debug("Error dialing peer", "err", err)
-				default:
-					sw.Logger.Error("Error dialing peer", "err", err)
-				}
-			}
-		}(i)
-	}
-}
-
-// DialPeerWithAddress dials the given peer and runs sw.addPeer if it connects
-// and authenticates successfully.
-// If we're currently dialing this address or it belongs to an existing peer,
-// ErrCurrentlyDialingOrExistingAddress is returned.
-func (sw *Switch) DialPeerWithAddress(addr *NetAddress) error {
-	if sw.IsDialingOrExistingAddress(addr) {
-		return ErrCurrentlyDialingOrExistingAddress{addr.String()}
-	}
-
-	sw.dialing.Set(string(addr.ID), addr)
-	defer sw.dialing.Delete(string(addr.ID))
-
-	return sw.addOutboundPeerWithConfig(addr, sw.config)
-}
-
-// sleep for interval plus some random amount of ms on [0, dialRandomizerIntervalMilliseconds]
-func (sw *Switch) randomSleep(interval time.Duration) {
-	// nolint:gosec // G404: Use of weak random number generator
-	r := time.Duration(mrand.Int63n(dialRandomizerIntervalMilliseconds)) * time.Millisecond
-	time.Sleep(r + interval)
-}
-
-// IsDialingOrExistingAddress returns true if switch has a peer with the given
-// address or dialing it at the moment.
-func (sw *Switch) IsDialingOrExistingAddress(addr *NetAddress) bool {
-	return sw.dialing.Has(string(addr.ID)) ||
-		sw.peers.Has(addr.ID) ||
-		(!sw.config.AllowDuplicateIP && sw.peers.HasIP(addr.IP))
-}
-
-// AddPersistentPeers allows you to set persistent peers. It ignores
-// ErrNetAddressLookup. However, if there are other errors, first encounter is
-// returned.
-func (sw *Switch) AddPersistentPeers(addrs []string) error {
-	sw.Logger.Info("Adding persistent peers", "addrs", addrs)
-	netAddrs, errs := NewNetAddressStrings(addrs)
-	// report all the errors
-	for _, err := range errs {
-		sw.Logger.Error("Error in peer's address", "err", err)
-	}
-	// return first non-ErrNetAddressLookup error
-	for _, err := range errs {
-		if _, ok := err.(types.ErrNetAddressLookup); ok {
-			continue
-		}
-		return err
-	}
-	sw.persistentPeersAddrs = netAddrs
-	return nil
-}
-
-func (sw *Switch) AddUnconditionalPeerIDs(ids []string) error {
-	sw.Logger.Info("Adding unconditional peer ids", "ids", ids)
-	for i, id := range ids {
-		err := types.NodeID(id).Validate()
-		if err != nil {
-			return fmt.Errorf("wrong ID #%d: %w", i, err)
-		}
-		sw.unconditionalPeerIDs[types.NodeID(id)] = struct{}{}
-	}
-	return nil
-}
-
-func (sw *Switch) AddPrivatePeerIDs(ids []string) error {
-	validIDs := make([]string, 0, len(ids))
-	for i, id := range ids {
-		err := types.NodeID(id).Validate()
-		if err != nil {
-			return fmt.Errorf("wrong ID #%d: %w", i, err)
-		}
-		validIDs = append(validIDs, id)
-	}
-
-	sw.addrBook.AddPrivateIDs(validIDs)
-
-	return nil
-}
-
-func (sw *Switch) IsPeerPersistent(na *NetAddress) bool {
-	for _, pa := range sw.persistentPeersAddrs {
-		if pa.Equals(na) {
-			return true
-		}
-	}
-	return false
-}
-
-func (sw *Switch) acceptRoutine() {
-	for {
-		var peerNodeInfo types.NodeInfo
-		c, err := sw.transport.Accept()
-		if err == nil {
-			// NOTE: The legacy MConn transport did handshaking in Accept(),
-			// which was asynchronous and avoided head-of-line-blocking.
-			// However, as handshakes are being migrated out from the transport,
-			// we just do it synchronously here for now.
-			peerNodeInfo, _, err = sw.handshakePeer(c, "")
-		}
-		if err == nil {
-			err = sw.filterConn(c.(*mConnConnection).conn)
-		}
-		if err != nil {
-			if c != nil {
-				_ = c.Close()
-			}
-			if err == io.EOF {
-				err = ErrTransportClosed{}
-			}
-			switch err := err.(type) {
-			case ErrRejected:
-				addr := err.Addr()
-				if err.IsSelf() {
-					// Remove the given address from the address book and add to our addresses
-					// to avoid dialing in the future.
-					sw.addrBook.RemoveAddress(&addr)
-					sw.addrBook.AddOurAddress(&addr)
-				}
-				if err.IsIncompatible() {
-					sw.addrBook.RemoveAddress(&addr)
-				}
-
-				sw.Logger.Info(
-					"Inbound Peer rejected",
-					"err", err,
-					"numPeers", sw.peers.Size(),
-				)
-
-				continue
-			case ErrFilterTimeout:
-				sw.Logger.Error(
-					"Peer filter timed out",
-					"err", err,
-				)
-
-				continue
-			case ErrTransportClosed:
-				sw.Logger.Error(
-					"Stopped accept routine, as transport is closed",
-					"numPeers", sw.peers.Size(),
-				)
-			default:
-				sw.Logger.Error(
-					"Accept on transport errored",
-					"err", err,
-					"numPeers", sw.peers.Size(),
-				)
-				// We could instead have a retry loop around the acceptRoutine,
-				// but that would need to stop and let the node shutdown eventually.
-				// So might as well panic and let process managers restart the node.
-				// There's no point in letting the node run without the acceptRoutine,
-				// since it won't be able to accept new connections.
-				panic(fmt.Errorf("accept routine exited: %v", err))
-			}
-
-			break
-		}
-
-		isPersistent := false
-		addr, err := peerNodeInfo.NetAddress()
-		if err == nil {
-			isPersistent = sw.IsPeerPersistent(addr)
-		}
-
-		p := newPeer(
-			peerNodeInfo,
-			newPeerConn(false, isPersistent, c),
-			sw.reactorsByCh,
-			sw.StopPeerForError,
-			PeerMetrics(sw.metrics),
-		)
-
-		if !sw.IsPeerUnconditional(p.NodeInfo().ID()) {
-			// Ignore connection if we already have enough peers.
-			_, in, _ := sw.NumPeers()
-			if in >= sw.config.MaxNumInboundPeers {
-				sw.Logger.Info(
-					"Ignoring inbound connection: already have enough inbound peers",
-					"address", p.SocketAddr(),
-					"have", in,
-					"max", sw.config.MaxNumInboundPeers,
-				)
-				_ = p.CloseConn()
-				continue
-			}
-
-		}
-
-		if err := sw.addPeer(p); err != nil {
-			_ = p.CloseConn()
-			if p.IsRunning() {
-				_ = p.Stop()
-			}
-			sw.conns.RemoveAddr(p.RemoteAddr())
-			sw.Logger.Info(
-				"Ignoring inbound connection: error while adding peer",
-				"err", err,
-				"id", p.ID(),
-			)
-		}
-	}
-}
-
-// dial the peer; make secret connection; authenticate against the dialed ID;
-// add the peer.
-// if dialing fails, start the reconnect loop. If handshake fails, it's over.
-// If peer is started successfully, reconnectLoop will start when
-// StopPeerForError is called.
-func (sw *Switch) addOutboundPeerWithConfig(
-	addr *NetAddress,
-	cfg *config.P2PConfig,
-) error {
-	sw.Logger.Info("Dialing peer", "address", addr)
-
-	// XXX(xla): Remove the leakage of test concerns in implementation.
-	if cfg.TestDialFail {
-		go sw.reconnectToPeer(addr)
-		return fmt.Errorf("dial err (peerConfig.DialFail == true)")
-	}
-
-	// Hardcoded timeout moved from MConn transport during refactoring.
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	var peerNodeInfo types.NodeInfo
-	c, err := sw.transport.Dial(ctx, Endpoint{
-		Protocol: MConnProtocol,
-		IP:       addr.IP,
-		Port:     addr.Port,
-	})
-	if err == nil {
-		peerNodeInfo, _, err = sw.handshakePeer(c, addr.ID)
-	}
-	if err == nil {
-		err = sw.filterConn(c.(*mConnConnection).conn)
-	}
-	if err != nil {
-		if c != nil {
-			_ = c.Close()
-		}
-		if e, ok := err.(ErrRejected); ok {
-			if e.IsSelf() {
-				// Remove the given address from the address book and add to our addresses
-				// to avoid dialing in the future.
-				sw.addrBook.RemoveAddress(addr)
-				sw.addrBook.AddOurAddress(addr)
-			}
-			if e.IsIncompatible() {
-				sw.addrBook.RemoveAddress(addr)
-			}
-
-			return err
-		}
-
-		// retry persistent peers after
-		// any dial error besides IsSelf()
-		if sw.IsPeerPersistent(addr) {
-			go sw.reconnectToPeer(addr)
-		}
-
-		return err
-	}
-
-	p := newPeer(
-		peerNodeInfo,
-		newPeerConn(true, sw.IsPeerPersistent(addr), c),
-		sw.reactorsByCh,
-		sw.StopPeerForError,
-		PeerMetrics(sw.metrics),
-	)
-
-	if err := sw.addPeer(p); err != nil {
-		_ = p.CloseConn()
-		if p.IsRunning() {
-			_ = p.Stop()
-		}
-		sw.conns.RemoveAddr(p.RemoteAddr())
-		return err
-	}
-
-	return nil
-}
-
-func (sw *Switch) handshakePeer(
-	c Connection,
-	expectPeerID types.NodeID,
-) (types.NodeInfo, crypto.PubKey, error) {
-	// Moved from transport and hardcoded until legacy P2P stack removal.
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	peerInfo, peerKey, err := c.Handshake(ctx, sw.nodeInfo, sw.nodeKey.PrivKey)
-	if err != nil {
-		return peerInfo, peerKey, ErrRejected{
-			conn:          c.(*mConnConnection).conn,
-			err:           fmt.Errorf("handshake failed: %v", err),
-			isAuthFailure: true,
-		}
-	}
-
-	if err = peerInfo.Validate(); err != nil {
-		return peerInfo, peerKey, ErrRejected{
-			conn:              c.(*mConnConnection).conn,
-			err:               err,
-			isNodeInfoInvalid: true,
-		}
-	}
-
-	// For outgoing conns, ensure connection key matches dialed key.
-	if expectPeerID != "" {
-		peerID := types.NodeIDFromPubKey(peerKey)
-		if expectPeerID != peerID {
-			return peerInfo, peerKey, ErrRejected{
-				conn: c.(*mConnConnection).conn,
-				id:   peerID,
-				err: fmt.Errorf(
-					"conn.ID (%v) dialed ID (%v) mismatch",
-					peerID,
-					expectPeerID,
-				),
-				isAuthFailure: true,
-			}
-		}
-	}
-
-	if sw.nodeInfo.ID() == peerInfo.ID() {
-		return peerInfo, peerKey, ErrRejected{
-			addr:   *types.NewNetAddress(peerInfo.ID(), c.(*mConnConnection).conn.RemoteAddr()),
-			conn:   c.(*mConnConnection).conn,
-			id:     peerInfo.ID(),
-			isSelf: true,
-		}
-	}
-
-	if err = sw.nodeInfo.CompatibleWith(peerInfo); err != nil {
-		return peerInfo, peerKey, ErrRejected{
-			conn:           c.(*mConnConnection).conn,
-			err:            err,
-			id:             peerInfo.ID(),
-			isIncompatible: true,
-		}
-	}
-
-	return peerInfo, peerKey, nil
-}
-
-func (sw *Switch) filterPeer(p Peer) error {
-	// Avoid duplicate
-	if sw.peers.Has(p.ID()) {
-		return ErrRejected{id: p.ID(), isDuplicate: true}
-	}
-
-	errc := make(chan error, len(sw.peerFilters))
-
-	for _, f := range sw.peerFilters {
-		go func(f PeerFilterFunc, p Peer, errc chan<- error) {
-			errc <- f(sw.peers, p)
-		}(f, p, errc)
-	}
-
-	for i := 0; i < cap(errc); i++ {
-		select {
-		case err := <-errc:
-			if err != nil {
-				return ErrRejected{id: p.ID(), err: err, isFiltered: true}
-			}
-		case <-time.After(sw.filterTimeout):
-			return ErrFilterTimeout{}
-		}
-	}
-
-	return nil
-}
-
-// filterConn filters a connection, rejecting it if this function errors.
-//
-// FIXME: This is only here for compatibility with the current Switch code. In
-// the new P2P stack, peer/connection filtering should be moved into the Router
-// or PeerManager and removed from here.
-func (sw *Switch) filterConn(conn net.Conn) error {
-	if sw.conns.Has(conn) {
-		return ErrRejected{conn: conn, isDuplicate: true}
-	}
-
-	host, _, err := net.SplitHostPort(conn.RemoteAddr().String())
-	if err != nil {
-		return err
-	}
-	ip := net.ParseIP(host)
-	if ip == nil {
-		return fmt.Errorf("connection address has invalid IP address %q", host)
-	}
-
-	// Apply filter callbacks.
-	chErr := make(chan error, len(sw.connFilters))
-	for _, connFilter := range sw.connFilters {
-		go func(connFilter ConnFilterFunc) {
-			chErr <- connFilter(sw.conns, conn, []net.IP{ip})
-		}(connFilter)
-	}
-
-	for i := 0; i < cap(chErr); i++ {
-		select {
-		case err := <-chErr:
-			if err != nil {
-				return ErrRejected{conn: conn, err: err, isFiltered: true}
-			}
-		case <-time.After(sw.filterTimeout):
-			return ErrFilterTimeout{}
-		}
-
-	}
-
-	// FIXME: Doesn't really make sense to set this here, but we preserve the
-	// behavior from the previous P2P transport implementation.
-	sw.conns.Set(conn, []net.IP{ip})
-	return nil
-}
-
-// addPeer starts up the Peer and adds it to the Switch. Error is returned if
-// the peer is filtered out or failed to start or can't be added.
-func (sw *Switch) addPeer(p Peer) error {
-	if err := sw.filterPeer(p); err != nil {
-		return err
-	}
-
-	p.SetLogger(sw.Logger.With("peer", p.SocketAddr()))
-
-	// Handle the shut down case where the switch has stopped but we're
-	// concurrently trying to add a peer.
-	if !sw.IsRunning() {
-		// XXX should this return an error or just log and terminate?
-		sw.Logger.Error("Won't start a peer - switch is not running", "peer", p)
-		return nil
-	}
-
-	// Add some data to the peer, which is required by reactors.
-	for _, reactor := range sw.reactors {
-		p = reactor.InitPeer(p)
-	}
-
-	// Start the peer's send/recv routines.
-	// Must start it before adding it to the peer set
-	// to prevent Start and Stop from being called concurrently.
-	err := p.Start()
-	if err != nil {
-		// Should never happen
-		sw.Logger.Error("Error starting peer", "err", err, "peer", p)
-		return err
-	}
-
-	// Add the peer to PeerSet. Do this before starting the reactors
-	// so that if Receive errors, we will find the peer and remove it.
-	// Add should not err since we already checked peers.Has().
-	if err := sw.peers.Add(p); err != nil {
-		return err
-	}
-	sw.metrics.Peers.Add(float64(1))
-
-	// Start all the reactor protocols on the peer.
-	for _, reactor := range sw.reactors {
-		reactor.AddPeer(p)
-	}
-
-	sw.Logger.Info("Added peer", "peer", p)
-
-	return nil
-}
-
-// NewNetAddressStrings returns an array of NetAddress'es build using
-// the provided strings.
-func NewNetAddressStrings(addrs []string) ([]*NetAddress, []error) {
-	netAddrs := make([]*NetAddress, 0)
-	errs := make([]error, 0)
-	for _, addr := range addrs {
-		netAddr, err := types.NewNetAddressString(addr)
-		if err != nil {
-			errs = append(errs, err)
-		} else {
-			netAddrs = append(netAddrs, netAddr)
-		}
-	}
-	return netAddrs, errs
-}
diff --git a/internal/p2p/switch_test.go b/internal/p2p/switch_test.go
deleted file mode 100644
index 8cb755c9fd..0000000000
--- a/internal/p2p/switch_test.go
+++ /dev/null
@@ -1,932 +0,0 @@
-package p2p
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"regexp"
-	"strconv"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus/promhttp"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/types"
-)
-
-var (
-	cfg *config.P2PConfig
-	ctx = context.Background()
-)
-
-func init() {
-	cfg = config.DefaultP2PConfig()
-	cfg.PexReactor = true
-	cfg.AllowDuplicateIP = true
-}
-
-type PeerMessage struct {
-	PeerID  types.NodeID
-	Bytes   []byte
-	Counter int
-}
-
-type TestReactor struct {
-	BaseReactor
-
-	mtx          tmsync.Mutex
-	channels     []*conn.ChannelDescriptor
-	logMessages  bool
-	msgsCounter  int
-	msgsReceived map[byte][]PeerMessage
-}
-
-func NewTestReactor(channels []*conn.ChannelDescriptor, logMessages bool) *TestReactor {
-	tr := &TestReactor{
-		channels:     channels,
-		logMessages:  logMessages,
-		msgsReceived: make(map[byte][]PeerMessage),
-	}
-	tr.BaseReactor = *NewBaseReactor("TestReactor", tr)
-	tr.SetLogger(log.TestingLogger())
-	return tr
-}
-
-func (tr *TestReactor) GetChannels() []*conn.ChannelDescriptor {
-	return tr.channels
-}
-
-func (tr *TestReactor) AddPeer(peer Peer) {}
-
-func (tr *TestReactor) RemovePeer(peer Peer, reason interface{}) {}
-
-func (tr *TestReactor) Receive(chID byte, peer Peer, msgBytes []byte) {
-	if tr.logMessages {
-		tr.mtx.Lock()
-		defer tr.mtx.Unlock()
-		// fmt.Printf("Received: %X, %X\n", chID, msgBytes)
-		tr.msgsReceived[chID] = append(tr.msgsReceived[chID], PeerMessage{peer.ID(), msgBytes, tr.msgsCounter})
-		tr.msgsCounter++
-	}
-}
-
-func (tr *TestReactor) getMsgs(chID byte) []PeerMessage {
-	tr.mtx.Lock()
-	defer tr.mtx.Unlock()
-	return tr.msgsReceived[chID]
-}
-
-//-----------------------------------------------------------------------------
-
-// convenience method for creating two switches connected to each other.
-// XXX: note this uses net.Pipe and not a proper TCP conn
-func MakeSwitchPair(t testing.TB, initSwitch func(int, *Switch) *Switch) (*Switch, *Switch) {
-	// Create two switches that will be interconnected.
-	switches := MakeConnectedSwitches(cfg, 2, initSwitch, Connect2Switches)
-	return switches[0], switches[1]
-}
-
-func initSwitchFunc(i int, sw *Switch) *Switch {
-	sw.SetAddrBook(&AddrBookMock{
-		Addrs:    make(map[string]struct{}),
-		OurAddrs: make(map[string]struct{})})
-
-	// Make two reactors of two channels each
-	sw.AddReactor("foo", NewTestReactor([]*conn.ChannelDescriptor{
-		{ID: byte(0x00), Priority: 10},
-		{ID: byte(0x01), Priority: 10},
-	}, true))
-	sw.AddReactor("bar", NewTestReactor([]*conn.ChannelDescriptor{
-		{ID: byte(0x02), Priority: 10},
-		{ID: byte(0x03), Priority: 10},
-	}, true))
-
-	return sw
-}
-
-func TestSwitches(t *testing.T) {
-	s1, s2 := MakeSwitchPair(t, initSwitchFunc)
-	t.Cleanup(func() {
-		if err := s1.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-	t.Cleanup(func() {
-		if err := s2.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	if s1.Peers().Size() != 1 {
-		t.Errorf("expected exactly 1 peer in s1, got %v", s1.Peers().Size())
-	}
-	if s2.Peers().Size() != 1 {
-		t.Errorf("expected exactly 1 peer in s2, got %v", s2.Peers().Size())
-	}
-
-	// Lets send some messages
-	ch0Msg := []byte("channel zero")
-	ch1Msg := []byte("channel foo")
-	ch2Msg := []byte("channel bar")
-
-	s1.Broadcast(byte(0x00), ch0Msg)
-	s1.Broadcast(byte(0x01), ch1Msg)
-	s1.Broadcast(byte(0x02), ch2Msg)
-
-	assertMsgReceivedWithTimeout(t,
-		ch0Msg,
-		byte(0x00),
-		s2.Reactor("foo").(*TestReactor), 10*time.Millisecond, 5*time.Second)
-	assertMsgReceivedWithTimeout(t,
-		ch1Msg,
-		byte(0x01),
-		s2.Reactor("foo").(*TestReactor), 10*time.Millisecond, 5*time.Second)
-	assertMsgReceivedWithTimeout(t,
-		ch2Msg,
-		byte(0x02),
-		s2.Reactor("bar").(*TestReactor), 10*time.Millisecond, 5*time.Second)
-}
-
-func assertMsgReceivedWithTimeout(
-	t *testing.T,
-	msgBytes []byte,
-	channel byte,
-	reactor *TestReactor,
-	checkPeriod,
-	timeout time.Duration,
-) {
-	ticker := time.NewTicker(checkPeriod)
-	for {
-		select {
-		case <-ticker.C:
-			msgs := reactor.getMsgs(channel)
-			if len(msgs) > 0 {
-				if !bytes.Equal(msgs[0].Bytes, msgBytes) {
-					t.Fatalf("Unexpected message bytes. Wanted: %X, Got: %X", msgBytes, msgs[0].Bytes)
-				}
-				return
-			}
-
-		case <-time.After(timeout):
-			t.Fatalf("Expected to have received 1 message in channel #%v, got zero", channel)
-		}
-	}
-}
-
-func TestSwitchFiltersOutItself(t *testing.T) {
-	s1 := MakeSwitch(cfg, 1, "127.0.0.1", "123.123.123", initSwitchFunc, log.TestingLogger())
-
-	// simulate s1 having a public IP by creating a remote peer with the same ID
-	rp := &remotePeer{PrivKey: s1.nodeKey.PrivKey, Config: cfg}
-	rp.Start()
-
-	// addr should be rejected in addPeer based on the same ID
-	err := s1.DialPeerWithAddress(rp.Addr())
-	if assert.Error(t, err) {
-		if err, ok := err.(ErrRejected); ok {
-			if !err.IsSelf() {
-				t.Errorf("expected self to be rejected")
-			}
-		} else {
-			t.Errorf("expected ErrRejected")
-		}
-	}
-
-	assert.True(t, s1.addrBook.OurAddress(rp.Addr()))
-	assert.False(t, s1.addrBook.HasAddress(rp.Addr()))
-
-	rp.Stop()
-
-	assertNoPeersAfterTimeout(t, s1, 100*time.Millisecond)
-}
-
-func TestSwitchDialFailsOnIncompatiblePeer(t *testing.T) {
-	s1 := MakeSwitch(cfg, 1, "127.0.0.1", "123.123.123", initSwitchFunc, log.TestingLogger())
-	ni := s1.NodeInfo()
-	ni.Network = "network-a"
-	s1.SetNodeInfo(ni)
-
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg, Network: "network-b"}
-	rp.Start()
-	defer rp.Stop()
-
-	err := s1.DialPeerWithAddress(rp.Addr())
-	require.Error(t, err)
-	errRejected, ok := err.(ErrRejected)
-	require.True(t, ok, "expected error to be of type IsRejected")
-	require.True(t, errRejected.IsIncompatible(), "expected error to be IsIncompatible")
-
-	// remote peer should not have been added to the addressbook
-	require.False(t, s1.addrBook.HasAddress(rp.Addr()))
-}
-
-func TestSwitchPeerFilter(t *testing.T) {
-	var (
-		filters = []PeerFilterFunc{
-			func(_ IPeerSet, _ Peer) error { return nil },
-			func(_ IPeerSet, _ Peer) error { return fmt.Errorf("denied") },
-			func(_ IPeerSet, _ Peer) error { return nil },
-		}
-		sw = MakeSwitch(
-			cfg,
-			1,
-			"testing",
-			"123.123.123",
-			initSwitchFunc,
-			log.TestingLogger(),
-			SwitchPeerFilters(filters...),
-		)
-	)
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	// simulate remote peer
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	t.Cleanup(rp.Stop)
-
-	c, err := sw.transport.Dial(ctx, NewEndpoint(rp.Addr()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	peerInfo, _, err := c.Handshake(ctx, sw.nodeInfo, sw.nodeKey.PrivKey)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p := newPeer(
-		peerInfo,
-		newPeerConn(true, false, c),
-		sw.reactorsByCh,
-		sw.StopPeerForError,
-	)
-
-	err = sw.addPeer(p)
-	if err, ok := err.(ErrRejected); ok {
-		if !err.IsFiltered() {
-			t.Errorf("expected peer to be filtered")
-		}
-	} else {
-		t.Errorf("expected ErrRejected")
-	}
-}
-
-func TestSwitchPeerFilterTimeout(t *testing.T) {
-	var (
-		filters = []PeerFilterFunc{
-			func(_ IPeerSet, _ Peer) error {
-				time.Sleep(10 * time.Millisecond)
-				return nil
-			},
-		}
-		sw = MakeSwitch(
-			cfg,
-			1,
-			"testing",
-			"123.123.123",
-			initSwitchFunc,
-			log.TestingLogger(),
-			SwitchFilterTimeout(5*time.Millisecond),
-			SwitchPeerFilters(filters...),
-		)
-	)
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Log(err)
-		}
-	})
-
-	// simulate remote peer
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	defer rp.Stop()
-
-	c, err := sw.transport.Dial(ctx, NewEndpoint(rp.Addr()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	peerInfo, _, err := c.Handshake(ctx, sw.nodeInfo, sw.nodeKey.PrivKey)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p := newPeer(
-		peerInfo,
-		newPeerConn(true, false, c),
-		sw.reactorsByCh,
-		sw.StopPeerForError,
-	)
-
-	err = sw.addPeer(p)
-	if _, ok := err.(ErrFilterTimeout); !ok {
-		t.Errorf("expected ErrFilterTimeout")
-	}
-}
-
-func TestSwitchPeerFilterDuplicate(t *testing.T) {
-	sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc, log.TestingLogger())
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	// simulate remote peer
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	defer rp.Stop()
-
-	c, err := sw.transport.Dial(ctx, NewEndpoint(rp.Addr()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	peerInfo, _, err := c.Handshake(ctx, sw.nodeInfo, sw.nodeKey.PrivKey)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p := newPeer(
-		peerInfo,
-		newPeerConn(true, false, c),
-		sw.reactorsByCh,
-		sw.StopPeerForError,
-	)
-
-	if err := sw.addPeer(p); err != nil {
-		t.Fatal(err)
-	}
-
-	err = sw.addPeer(p)
-	if errRej, ok := err.(ErrRejected); ok {
-		if !errRej.IsDuplicate() {
-			t.Errorf("expected peer to be duplicate. got %v", errRej)
-		}
-	} else {
-		t.Errorf("expected ErrRejected, got %v", err)
-	}
-}
-
-func assertNoPeersAfterTimeout(t *testing.T, sw *Switch, timeout time.Duration) {
-	time.Sleep(timeout)
-	if sw.Peers().Size() != 0 {
-		t.Fatalf("Expected %v to not connect to some peers, got %d", sw, sw.Peers().Size())
-	}
-}
-
-func TestSwitchStopsNonPersistentPeerOnError(t *testing.T) {
-	assert, require := assert.New(t), require.New(t)
-
-	sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc, log.TestingLogger())
-	err := sw.Start()
-	if err != nil {
-		t.Error(err)
-	}
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	// simulate remote peer
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	defer rp.Stop()
-
-	c, err := sw.transport.Dial(ctx, NewEndpoint(rp.Addr()))
-	if err != nil {
-		t.Fatal(err)
-	}
-	peerInfo, _, err := c.Handshake(ctx, sw.nodeInfo, sw.nodeKey.PrivKey)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p := newPeer(
-		peerInfo,
-		newPeerConn(true, false, c),
-		sw.reactorsByCh,
-		sw.StopPeerForError,
-	)
-
-	err = sw.addPeer(p)
-	require.Nil(err)
-
-	require.NotNil(sw.Peers().Get(rp.ID()))
-
-	// simulate failure by closing connection
-	err = p.CloseConn()
-	require.NoError(err)
-
-	assertNoPeersAfterTimeout(t, sw, 100*time.Millisecond)
-	assert.False(p.IsRunning())
-}
-
-func TestSwitchStopPeerForError(t *testing.T) {
-	s := httptest.NewServer(promhttp.Handler())
-	defer s.Close()
-
-	scrapeMetrics := func() string {
-		resp, err := http.Get(s.URL)
-		require.NoError(t, err)
-		defer resp.Body.Close()
-		buf, _ := ioutil.ReadAll(resp.Body)
-		return string(buf)
-	}
-
-	namespace, subsystem, name := config.TestInstrumentationConfig().Namespace, MetricsSubsystem, "peers"
-	re := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + ` ([0-9\.]+)`)
-	peersMetricValue := func() float64 {
-		matches := re.FindStringSubmatch(scrapeMetrics())
-		f, _ := strconv.ParseFloat(matches[1], 64)
-		return f
-	}
-
-	p2pMetrics := PrometheusMetrics(namespace)
-
-	// make two connected switches
-	sw1, sw2 := MakeSwitchPair(t, func(i int, sw *Switch) *Switch {
-		// set metrics on sw1
-		if i == 0 {
-			opt := WithMetrics(p2pMetrics)
-			opt(sw)
-		}
-		return initSwitchFunc(i, sw)
-	})
-
-	assert.Equal(t, len(sw1.Peers().List()), 1)
-	assert.EqualValues(t, 1, peersMetricValue())
-
-	// send messages to the peer from sw1
-	p := sw1.Peers().List()[0]
-	p.Send(0x1, []byte("here's a message to send"))
-
-	// stop sw2. this should cause the p to fail,
-	// which results in calling StopPeerForError internally
-	t.Cleanup(func() {
-		if err := sw2.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	// now call StopPeerForError explicitly, eg. from a reactor
-	sw1.StopPeerForError(p, fmt.Errorf("some err"))
-
-	assert.Equal(t, len(sw1.Peers().List()), 0)
-	assert.EqualValues(t, 0, peersMetricValue())
-}
-
-func TestSwitchReconnectsToOutboundPersistentPeer(t *testing.T) {
-	sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc, log.TestingLogger())
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	// 1. simulate failure by closing connection
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	defer rp.Stop()
-
-	err = sw.AddPersistentPeers([]string{rp.Addr().String()})
-	require.NoError(t, err)
-
-	err = sw.DialPeerWithAddress(rp.Addr())
-	require.Nil(t, err)
-	require.NotNil(t, sw.Peers().Get(rp.ID()))
-
-	p := sw.Peers().List()[0]
-	err = p.(*peer).CloseConn()
-	require.NoError(t, err)
-
-	waitUntilSwitchHasAtLeastNPeers(sw, 1)
-	assert.False(t, p.IsRunning())        // old peer instance
-	assert.Equal(t, 1, sw.Peers().Size()) // new peer instance
-
-	// 2. simulate first time dial failure
-	rp = &remotePeer{
-		PrivKey: ed25519.GenPrivKey(),
-		Config:  cfg,
-		// Use different interface to prevent duplicate IP filter, this will break
-		// beyond two peers.
-		listenAddr: "127.0.0.1:0",
-	}
-	rp.Start()
-	defer rp.Stop()
-
-	conf := config.DefaultP2PConfig()
-	conf.TestDialFail = true // will trigger a reconnect
-	err = sw.addOutboundPeerWithConfig(rp.Addr(), conf)
-	require.NotNil(t, err)
-	// DialPeerWithAddres - sw.peerConfig resets the dialer
-	waitUntilSwitchHasAtLeastNPeers(sw, 2)
-	assert.Equal(t, 2, sw.Peers().Size())
-}
-
-func TestSwitchReconnectsToInboundPersistentPeer(t *testing.T) {
-	sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc, log.TestingLogger())
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	// 1. simulate failure by closing the connection
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	defer rp.Stop()
-
-	err = sw.AddPersistentPeers([]string{rp.Addr().String()})
-	require.NoError(t, err)
-
-	conn, err := rp.Dial(sw.NetAddress())
-	require.NoError(t, err)
-	time.Sleep(50 * time.Millisecond)
-	require.NotNil(t, sw.Peers().Get(rp.ID()))
-
-	conn.Close()
-
-	waitUntilSwitchHasAtLeastNPeers(sw, 1)
-	assert.Equal(t, 1, sw.Peers().Size())
-}
-
-func TestSwitchDialPeersAsync(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc, log.TestingLogger())
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	defer rp.Stop()
-
-	err = sw.DialPeersAsync([]string{rp.Addr().String()})
-	require.NoError(t, err)
-	time.Sleep(dialRandomizerIntervalMilliseconds * time.Millisecond)
-	require.NotNil(t, sw.Peers().Get(rp.ID()))
-}
-
-func waitUntilSwitchHasAtLeastNPeers(sw *Switch, n int) {
-	for i := 0; i < 20; i++ {
-		time.Sleep(250 * time.Millisecond)
-		has := sw.Peers().Size()
-		if has >= n {
-			break
-		}
-	}
-}
-
-func TestSwitchFullConnectivity(t *testing.T) {
-	switches := MakeConnectedSwitches(cfg, 3, initSwitchFunc, Connect2Switches)
-	defer func() {
-		for _, sw := range switches {
-			sw := sw
-			t.Cleanup(func() {
-				if err := sw.Stop(); err != nil {
-					t.Error(err)
-				}
-			})
-		}
-	}()
-
-	for i, sw := range switches {
-		if sw.Peers().Size() != 2 {
-			t.Fatalf("Expected each switch to be connected to 2 other, but %d switch only connected to %d", sw.Peers().Size(), i)
-		}
-	}
-}
-
-func TestSwitchAcceptRoutine(t *testing.T) {
-	cfg.MaxNumInboundPeers = 5
-
-	// Create some unconditional peers.
-	const unconditionalPeersNum = 2
-	var (
-		unconditionalPeers   = make([]*remotePeer, unconditionalPeersNum)
-		unconditionalPeerIDs = make([]string, unconditionalPeersNum)
-	)
-	for i := 0; i < unconditionalPeersNum; i++ {
-		peer := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-		peer.Start()
-		unconditionalPeers[i] = peer
-		unconditionalPeerIDs[i] = string(peer.ID())
-	}
-
-	// make switch
-	sw := MakeSwitch(cfg, 1, "testing", "123.123.123", initSwitchFunc, log.TestingLogger())
-	err := sw.AddUnconditionalPeerIDs(unconditionalPeerIDs)
-	require.NoError(t, err)
-	err = sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		err := sw.Stop()
-		require.NoError(t, err)
-	})
-
-	// 0. check there are no peers
-	assert.Equal(t, 0, sw.Peers().Size())
-
-	// 1. check we connect up to MaxNumInboundPeers
-	peers := make([]*remotePeer, 0)
-	for i := 0; i < cfg.MaxNumInboundPeers; i++ {
-		peer := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-		peers = append(peers, peer)
-		peer.Start()
-		c, err := peer.Dial(sw.NetAddress())
-		require.NoError(t, err)
-		// spawn a reading routine to prevent connection from closing
-		go func(c net.Conn) {
-			for {
-				one := make([]byte, 1)
-				_, err := c.Read(one)
-				if err != nil {
-					return
-				}
-			}
-		}(c)
-	}
-	time.Sleep(100 * time.Millisecond)
-	assert.Equal(t, cfg.MaxNumInboundPeers, sw.Peers().Size())
-
-	// 2. check we close new connections if we already have MaxNumInboundPeers peers
-	peer := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	peer.Start()
-	conn, err := peer.Dial(sw.NetAddress())
-	require.NoError(t, err)
-	// check conn is closed
-	one := make([]byte, 1)
-	_ = conn.SetReadDeadline(time.Now().Add(10 * time.Millisecond))
-	_, err = conn.Read(one)
-	assert.Error(t, err)
-	assert.Equal(t, cfg.MaxNumInboundPeers, sw.Peers().Size())
-	peer.Stop()
-
-	// 3. check we connect to unconditional peers despite the limit.
-	for _, peer := range unconditionalPeers {
-		c, err := peer.Dial(sw.NetAddress())
-		require.NoError(t, err)
-		// spawn a reading routine to prevent connection from closing
-		go func(c net.Conn) {
-			for {
-				one := make([]byte, 1)
-				_, err := c.Read(one)
-				if err != nil {
-					return
-				}
-			}
-		}(c)
-	}
-	time.Sleep(10 * time.Millisecond)
-	assert.Equal(t, cfg.MaxNumInboundPeers+unconditionalPeersNum, sw.Peers().Size())
-
-	for _, peer := range peers {
-		peer.Stop()
-	}
-	for _, peer := range unconditionalPeers {
-		peer.Stop()
-	}
-}
-
-func TestSwitchRejectsIncompatiblePeers(t *testing.T) {
-	sw := MakeSwitch(cfg, 1, "127.0.0.1", "123.123.123", initSwitchFunc, log.TestingLogger())
-	ni := sw.NodeInfo()
-	ni.Network = "network-a"
-	sw.SetNodeInfo(ni)
-
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		err := sw.Stop()
-		require.NoError(t, err)
-	})
-
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg, Network: "network-b"}
-	rp.Start()
-	defer rp.Stop()
-
-	assert.Equal(t, 0, sw.Peers().Size())
-
-	conn, err := rp.Dial(sw.NetAddress())
-	assert.Nil(t, err)
-
-	one := make([]byte, 1)
-	_ = conn.SetReadDeadline(time.Now().Add(10 * time.Millisecond))
-	_, err = conn.Read(one)
-	assert.Error(t, err)
-
-	assert.Equal(t, 0, sw.Peers().Size())
-}
-
-type errorTransport struct {
-	acceptErr error
-}
-
-func (et errorTransport) String() string {
-	return "error"
-}
-
-func (et errorTransport) Protocols() []Protocol {
-	return []Protocol{"error"}
-}
-
-func (et errorTransport) Accept() (Connection, error) {
-	return nil, et.acceptErr
-}
-func (errorTransport) Dial(context.Context, Endpoint) (Connection, error) {
-	panic("not implemented")
-}
-func (errorTransport) Close() error          { panic("not implemented") }
-func (errorTransport) FlushClose() error     { panic("not implemented") }
-func (errorTransport) Endpoints() []Endpoint { panic("not implemented") }
-
-func TestSwitchAcceptRoutineErrorCases(t *testing.T) {
-	sw := NewSwitch(cfg, errorTransport{ErrFilterTimeout{}})
-	assert.NotPanics(t, func() {
-		err := sw.Start()
-		require.NoError(t, err)
-		err = sw.Stop()
-		require.NoError(t, err)
-	})
-
-	sw = NewSwitch(cfg, errorTransport{ErrRejected{conn: nil, err: errors.New("filtered"), isFiltered: true}})
-	assert.NotPanics(t, func() {
-		err := sw.Start()
-		require.NoError(t, err)
-		err = sw.Stop()
-		require.NoError(t, err)
-	})
-	// TODO(melekes) check we remove our address from addrBook
-
-	sw = NewSwitch(cfg, errorTransport{ErrTransportClosed{}})
-	assert.NotPanics(t, func() {
-		err := sw.Start()
-		require.NoError(t, err)
-		err = sw.Stop()
-		require.NoError(t, err)
-	})
-}
-
-// mockReactor checks that InitPeer never called before RemovePeer. If that's
-// not true, InitCalledBeforeRemoveFinished will return true.
-type mockReactor struct {
-	*BaseReactor
-
-	// atomic
-	removePeerInProgress           uint32
-	initCalledBeforeRemoveFinished uint32
-}
-
-func (r *mockReactor) GetChannels() []*ChannelDescriptor {
-	return []*ChannelDescriptor{{ID: testCh, Priority: 10}}
-}
-
-func (r *mockReactor) RemovePeer(peer Peer, reason interface{}) {
-	atomic.StoreUint32(&r.removePeerInProgress, 1)
-	defer atomic.StoreUint32(&r.removePeerInProgress, 0)
-	time.Sleep(100 * time.Millisecond)
-}
-
-func (r *mockReactor) InitPeer(peer Peer) Peer {
-	if atomic.LoadUint32(&r.removePeerInProgress) == 1 {
-		atomic.StoreUint32(&r.initCalledBeforeRemoveFinished, 1)
-	}
-
-	return peer
-}
-
-func (r *mockReactor) InitCalledBeforeRemoveFinished() bool {
-	return atomic.LoadUint32(&r.initCalledBeforeRemoveFinished) == 1
-}
-
-// see stopAndRemovePeer
-func TestSwitchInitPeerIsNotCalledBeforeRemovePeer(t *testing.T) {
-	// make reactor
-	reactor := &mockReactor{}
-	reactor.BaseReactor = NewBaseReactor("mockReactor", reactor)
-
-	// make switch
-	sw := MakeSwitch(cfg, 1, "testing", "123.123.123", func(i int, sw *Switch) *Switch {
-		sw.AddReactor("mock", reactor)
-		return sw
-	}, log.TestingLogger())
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	// add peer
-	rp := &remotePeer{PrivKey: ed25519.GenPrivKey(), Config: cfg}
-	rp.Start()
-	defer rp.Stop()
-	_, err = rp.Dial(sw.NetAddress())
-	require.NoError(t, err)
-
-	// wait till the switch adds rp to the peer set, then stop the peer asynchronously
-	for {
-		time.Sleep(20 * time.Millisecond)
-		if peer := sw.Peers().Get(rp.ID()); peer != nil {
-			go sw.StopPeerForError(peer, "test")
-			break
-		}
-	}
-
-	// simulate peer reconnecting to us
-	_, err = rp.Dial(sw.NetAddress())
-	require.NoError(t, err)
-	// wait till the switch adds rp to the peer set
-	time.Sleep(50 * time.Millisecond)
-
-	// make sure reactor.RemovePeer is finished before InitPeer is called
-	assert.False(t, reactor.InitCalledBeforeRemoveFinished())
-}
-
-func BenchmarkSwitchBroadcast(b *testing.B) {
-	s1, s2 := MakeSwitchPair(b, func(i int, sw *Switch) *Switch {
-		// Make bar reactors of bar channels each
-		sw.AddReactor("foo", NewTestReactor([]*conn.ChannelDescriptor{
-			{ID: byte(0x00), Priority: 10},
-			{ID: byte(0x01), Priority: 10},
-		}, false))
-		sw.AddReactor("bar", NewTestReactor([]*conn.ChannelDescriptor{
-			{ID: byte(0x02), Priority: 10},
-			{ID: byte(0x03), Priority: 10},
-		}, false))
-		return sw
-	})
-
-	b.Cleanup(func() {
-		if err := s1.Stop(); err != nil {
-			b.Error(err)
-		}
-	})
-
-	b.Cleanup(func() {
-		if err := s2.Stop(); err != nil {
-			b.Error(err)
-		}
-	})
-
-	// Allow time for goroutines to boot up
-	time.Sleep(1 * time.Second)
-
-	b.ResetTimer()
-
-	numSuccess, numFailure := 0, 0
-
-	// Send random message from foo channel to another
-	for i := 0; i < b.N; i++ {
-		chID := byte(i % 4)
-		successChan := s1.Broadcast(chID, []byte("test data"))
-		for s := range successChan {
-			if s {
-				numSuccess++
-			} else {
-				numFailure++
-			}
-		}
-	}
-
-	b.Logf("success: %v, failure: %v", numSuccess, numFailure)
-}
-
-func TestNewNetAddressStrings(t *testing.T) {
-	addrs, errs := NewNetAddressStrings([]string{
-		"127.0.0.1:8080",
-		"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-		"deadbeefdeadbeefdeadbeefdeadbeefdeadbeed@127.0.0.2:8080"})
-	assert.Len(t, errs, 1)
-	assert.Equal(t, 2, len(addrs))
-}
diff --git a/internal/p2p/test_util.go b/internal/p2p/test_util.go
index b2851646d4..d29709a89d 100644
--- a/internal/p2p/test_util.go
+++ b/internal/p2p/test_util.go
@@ -1,42 +1,15 @@
 package p2p
 
 import (
-	"context"
 	"fmt"
 	mrand "math/rand"
-	"net"
 
-	"github.com/tendermint/tendermint/libs/log"
-	tmnet "github.com/tendermint/tendermint/libs/net"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	"github.com/tendermint/tendermint/types"
-
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
 )
 
-const testCh = 0x01
-
 //------------------------------------------------
 
-func AddPeerToSwitchPeerSet(sw *Switch, peer Peer) {
-	sw.peers.Add(peer) //nolint:errcheck // ignore error
-}
-
-func CreateRandomPeer(outbound bool) Peer {
-	addr, netAddr := CreateRoutableAddr()
-	p := &peer{
-		peerConn: peerConn{outbound: outbound},
-		nodeInfo: types.NodeInfo{
-			NodeID:     netAddr.ID,
-			ListenAddr: netAddr.DialString(),
-		},
-		metrics: NopMetrics(),
-	}
-	p.SetLogger(log.TestingLogger().With("peer", addr))
-	return p
-}
-
 // nolint:gosec // G404: Use of weak random number generator
 func CreateRoutableAddr() (addr string, netAddr *NetAddress) {
 	for {
@@ -57,232 +30,3 @@ func CreateRoutableAddr() (addr string, netAddr *NetAddress) {
 	}
 	return
 }
-
-//------------------------------------------------------------------
-// Connects switches via arbitrary net.Conn. Used for testing.
-
-const TestHost = "localhost"
-
-// MakeConnectedSwitches returns n switches, connected according to the connect func.
-// If connect==Connect2Switches, the switches will be fully connected.
-// initSwitch defines how the i'th switch should be initialized (ie. with what reactors).
-// NOTE: panics if any switch fails to start.
-func MakeConnectedSwitches(cfg *config.P2PConfig,
-	n int,
-	initSwitch func(int, *Switch) *Switch,
-	connect func([]*Switch, int, int),
-) []*Switch {
-	switches := make([]*Switch, n)
-	for i := 0; i < n; i++ {
-		switches[i] = MakeSwitch(cfg, i, TestHost, "123.123.123", initSwitch, log.TestingLogger())
-	}
-
-	if err := StartSwitches(switches); err != nil {
-		panic(err)
-	}
-
-	for i := 0; i < n; i++ {
-		for j := i + 1; j < n; j++ {
-			connect(switches, i, j)
-		}
-	}
-
-	return switches
-}
-
-// Connect2Switches will connect switches i and j via net.Pipe().
-// Blocks until a connection is established.
-// NOTE: caller ensures i and j are within bounds.
-func Connect2Switches(switches []*Switch, i, j int) {
-	switchI := switches[i]
-	switchJ := switches[j]
-
-	c1, c2 := conn.NetPipe()
-
-	doneCh := make(chan struct{})
-	go func() {
-		err := switchI.addPeerWithConnection(c1)
-		if err != nil {
-			panic(err)
-		}
-		doneCh <- struct{}{}
-	}()
-	go func() {
-		err := switchJ.addPeerWithConnection(c2)
-		if err != nil {
-			panic(err)
-		}
-		doneCh <- struct{}{}
-	}()
-	<-doneCh
-	<-doneCh
-}
-
-func (sw *Switch) addPeerWithConnection(conn net.Conn) error {
-	pc, err := testInboundPeerConn(sw.transport.(*MConnTransport), conn)
-	if err != nil {
-		if err := conn.Close(); err != nil {
-			sw.Logger.Error("Error closing connection", "err", err)
-		}
-		return err
-	}
-	peerNodeInfo, _, err := pc.conn.Handshake(context.Background(), sw.nodeInfo, sw.nodeKey.PrivKey)
-	if err != nil {
-		if err := conn.Close(); err != nil {
-			sw.Logger.Error("Error closing connection", "err", err)
-		}
-		return err
-	}
-
-	p := newPeer(
-		peerNodeInfo,
-		pc,
-		sw.reactorsByCh,
-		sw.StopPeerForError,
-	)
-
-	if err = sw.addPeer(p); err != nil {
-		pc.CloseConn()
-		return err
-	}
-
-	return nil
-}
-
-// StartSwitches calls sw.Start() for each given switch.
-// It returns the first encountered error.
-func StartSwitches(switches []*Switch) error {
-	for _, s := range switches {
-		err := s.Start() // start switch and reactors
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func MakeSwitch(
-	cfg *config.P2PConfig,
-	i int,
-	network, version string,
-	initSwitch func(int, *Switch) *Switch,
-	logger log.Logger,
-	opts ...SwitchOption,
-) *Switch {
-
-	nodeKey := types.GenNodeKey()
-	nodeInfo := testNodeInfo(nodeKey.ID, fmt.Sprintf("node%d", i))
-	addr, err := types.NewNetAddressString(
-		nodeKey.ID.AddressString(nodeInfo.ListenAddr),
-	)
-	if err != nil {
-		panic(err)
-	}
-
-	swLogger := logger.With("switch", i)
-	t := NewMConnTransport(swLogger, MConnConfig(cfg),
-		[]*ChannelDescriptor{}, MConnTransportOptions{})
-
-	// TODO: let the config be passed in?
-	sw := initSwitch(i, NewSwitch(cfg, t, opts...))
-	sw.SetLogger(swLogger)
-	sw.SetNodeKey(nodeKey)
-
-	if err := t.Listen(NewEndpoint(addr)); err != nil {
-		panic(err)
-	}
-
-	ni := nodeInfo
-	ni.Channels = []byte{}
-	for ch := range sw.reactorsByCh {
-		ni.Channels = append(ni.Channels, ch)
-	}
-	nodeInfo = ni
-
-	// TODO: We need to setup reactors ahead of time so the NodeInfo is properly
-	// populated and we don't have to do those awkward overrides and setters.
-	sw.SetNodeInfo(nodeInfo)
-
-	return sw
-}
-
-func testInboundPeerConn(
-	transport *MConnTransport,
-	conn net.Conn,
-) (peerConn, error) {
-	return testPeerConn(transport, conn, false, false)
-}
-
-func testPeerConn(
-	transport *MConnTransport,
-	rawConn net.Conn,
-	outbound, persistent bool,
-) (pc peerConn, err error) {
-
-	conn := newMConnConnection(transport.logger, rawConn, transport.mConnConfig, transport.channelDescs)
-
-	return newPeerConn(outbound, persistent, conn), nil
-}
-
-//----------------------------------------------------------------
-// rand node info
-
-func testNodeInfo(id types.NodeID, name string) types.NodeInfo {
-	return testNodeInfoWithNetwork(id, name, "testing")
-}
-
-func testNodeInfoWithNetwork(id types.NodeID, name, network string) types.NodeInfo {
-	return types.NodeInfo{
-		ProtocolVersion: defaultProtocolVersion,
-		NodeID:          id,
-		ListenAddr:      fmt.Sprintf("127.0.0.1:%d", getFreePort()),
-		Network:         network,
-		Version:         "1.2.3-rc0-deadbeef",
-		Channels:        []byte{testCh},
-		Moniker:         name,
-		Other: types.NodeInfoOther{
-			TxIndex:    "on",
-			RPCAddress: fmt.Sprintf("127.0.0.1:%d", getFreePort()),
-		},
-	}
-}
-
-func getFreePort() int {
-	port, err := tmnet.GetFreePort()
-	if err != nil {
-		panic(err)
-	}
-	return port
-}
-
-type AddrBookMock struct {
-	Addrs        map[string]struct{}
-	OurAddrs     map[string]struct{}
-	PrivateAddrs map[string]struct{}
-}
-
-var _ AddrBook = (*AddrBookMock)(nil)
-
-func (book *AddrBookMock) AddAddress(addr *NetAddress, src *NetAddress) error {
-	book.Addrs[addr.String()] = struct{}{}
-	return nil
-}
-func (book *AddrBookMock) AddOurAddress(addr *NetAddress) { book.OurAddrs[addr.String()] = struct{}{} }
-func (book *AddrBookMock) OurAddress(addr *NetAddress) bool {
-	_, ok := book.OurAddrs[addr.String()]
-	return ok
-}
-func (book *AddrBookMock) MarkGood(types.NodeID) {}
-func (book *AddrBookMock) HasAddress(addr *NetAddress) bool {
-	_, ok := book.Addrs[addr.String()]
-	return ok
-}
-func (book *AddrBookMock) RemoveAddress(addr *NetAddress) {
-	delete(book.Addrs, addr.String())
-}
-func (book *AddrBookMock) Save() {}
-func (book *AddrBookMock) AddPrivateIDs(addrs []string) {
-	for _, addr := range addrs {
-		book.PrivateAddrs[addr] = struct{}{}
-	}
-}
diff --git a/internal/p2p/transport.go b/internal/p2p/transport.go
index a3245dfc8d..0b2311fa3f 100644
--- a/internal/p2p/transport.go
+++ b/internal/p2p/transport.go
@@ -9,7 +9,6 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/internal/p2p/conn"
 	"github.com/tendermint/tendermint/types"
-	"github.com/tendermint/tendermint/version"
 )
 
 //go:generate ../../scripts/mockery_generate.sh Transport|Connection
@@ -20,14 +19,6 @@ const (
 	defaultProtocol Protocol = MConnProtocol
 )
 
-// defaultProtocolVersion populates the Block and P2P versions using
-// the global values, but not the App.
-var defaultProtocolVersion = types.ProtocolVersion{
-	P2P:   version.P2PProtocol,
-	Block: version.BlockProtocol,
-	App:   0,
-}
-
 // Protocol identifies a transport protocol.
 type Protocol string
 
diff --git a/internal/rpc/core/consensus.go b/internal/rpc/core/consensus.go
index ac49bbd31c..d17796fff1 100644
--- a/internal/rpc/core/consensus.go
+++ b/internal/rpc/core/consensus.go
@@ -1,13 +1,9 @@
 package core
 
 import (
-	"errors"
-
-	"github.com/tendermint/tendermint/internal/consensus"
 	tmmath "github.com/tendermint/tendermint/libs/math"
 	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
-	"github.com/tendermint/tendermint/types"
 )
 
 // Validators gets the validator set at the given block height.
@@ -58,52 +54,28 @@ func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*coretypes.Re
 	// Get Peer consensus states.
 
 	var peerStates []coretypes.PeerStateInfo
-	switch {
-	case env.P2PPeers != nil:
-		peers := env.P2PPeers.Peers().List()
-		peerStates = make([]coretypes.PeerStateInfo, 0, len(peers))
-		for _, peer := range peers {
-			peerState, ok := peer.Get(types.PeerStateKey).(*consensus.PeerState)
-			if !ok { // peer does not have a state yet
-				continue
-			}
-			peerStateJSON, err := peerState.ToJSON()
-			if err != nil {
-				return nil, err
-			}
+	peers := env.PeerManager.Peers()
+	peerStates = make([]coretypes.PeerStateInfo, 0, len(peers))
+	for _, pid := range peers {
+		peerState, ok := env.ConsensusReactor.GetPeerState(pid)
+		if !ok {
+			continue
+		}
+
+		peerStateJSON, err := peerState.ToJSON()
+		if err != nil {
+			return nil, err
+		}
+
+		addr := env.PeerManager.Addresses(pid)
+		if len(addr) != 0 {
 			peerStates = append(peerStates, coretypes.PeerStateInfo{
 				// Peer basic info.
-				NodeAddress: peer.SocketAddr().String(),
+				NodeAddress: addr[0].String(),
 				// Peer consensus state.
 				PeerState: peerStateJSON,
 			})
 		}
-	case env.PeerManager != nil:
-		peers := env.PeerManager.Peers()
-		peerStates = make([]coretypes.PeerStateInfo, 0, len(peers))
-		for _, pid := range peers {
-			peerState, ok := env.ConsensusReactor.GetPeerState(pid)
-			if !ok {
-				continue
-			}
-
-			peerStateJSON, err := peerState.ToJSON()
-			if err != nil {
-				return nil, err
-			}
-
-			addr := env.PeerManager.Addresses(pid)
-			if len(addr) >= 1 {
-				peerStates = append(peerStates, coretypes.PeerStateInfo{
-					// Peer basic info.
-					NodeAddress: addr[0].String(),
-					// Peer consensus state.
-					PeerState: peerStateJSON,
-				})
-			}
-		}
-	default:
-		return nil, errors.New("no peer system configured")
 	}
 
 	// Get self round state.
diff --git a/internal/rpc/core/env.go b/internal/rpc/core/env.go
index 11b138eacd..f05c34f146 100644
--- a/internal/rpc/core/env.go
+++ b/internal/rpc/core/env.go
@@ -51,14 +51,6 @@ type transport interface {
 	NodeInfo() types.NodeInfo
 }
 
-type peers interface {
-	AddPersistentPeers([]string) error
-	AddUnconditionalPeerIDs([]string) error
-	AddPrivatePeerIDs([]string) error
-	DialPeersAsync([]string) error
-	Peers() p2p.IPeerSet
-}
-
 type consensusReactor interface {
 	WaitSync() bool
 	GetPeerState(peerID types.NodeID) (*consensus.PeerState, bool)
@@ -83,7 +75,6 @@ type Environment struct {
 	EvidencePool     sm.EvidencePool
 	ConsensusState   consensusState
 	ConsensusReactor consensusReactor
-	P2PPeers         peers
 
 	// Legacy p2p stack
 	P2PTransport transport
diff --git a/internal/rpc/core/net.go b/internal/rpc/core/net.go
index 8bcc04dd0c..fdf4be69b8 100644
--- a/internal/rpc/core/net.go
+++ b/internal/rpc/core/net.go
@@ -3,9 +3,7 @@ package core
 import (
 	"errors"
 	"fmt"
-	"strings"
 
-	"github.com/tendermint/tendermint/internal/p2p"
 	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
@@ -13,33 +11,19 @@ import (
 // NetInfo returns network info.
 // More: https://docs.tendermint.com/master/rpc/#/Info/net_info
 func (env *Environment) NetInfo(ctx *rpctypes.Context) (*coretypes.ResultNetInfo, error) {
-	var peers []coretypes.Peer
+	peerList := env.PeerManager.Peers()
 
-	switch {
-	case env.P2PPeers != nil:
-		peersList := env.P2PPeers.Peers().List()
-		peers = make([]coretypes.Peer, 0, len(peersList))
-		for _, peer := range peersList {
-			peers = append(peers, coretypes.Peer{
-				ID:  peer.ID(),
-				URL: peer.SocketAddr().String(),
-			})
+	peers := make([]coretypes.Peer, 0, len(peerList))
+	for _, peer := range peerList {
+		addrs := env.PeerManager.Addresses(peer)
+		if len(addrs) == 0 {
+			continue
 		}
-	case env.PeerManager != nil:
-		peerList := env.PeerManager.Peers()
-		for _, peer := range peerList {
-			addrs := env.PeerManager.Addresses(peer)
-			if len(addrs) == 0 {
-				continue
-			}
 
-			peers = append(peers, coretypes.Peer{
-				ID:  peer,
-				URL: addrs[0].String(),
-			})
-		}
-	default:
-		return nil, errors.New("peer management system does not support NetInfo responses")
+		peers = append(peers, coretypes.Peer{
+			ID:  peer,
+			URL: addrs[0].String(),
+		})
 	}
 
 	return &coretypes.ResultNetInfo{
@@ -50,70 +34,6 @@ func (env *Environment) NetInfo(ctx *rpctypes.Context) (*coretypes.ResultNetInfo
 	}, nil
 }
 
-// UnsafeDialSeeds dials the given seeds (comma-separated id@IP:PORT).
-func (env *Environment) UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*coretypes.ResultDialSeeds, error) {
-	if env.P2PPeers == nil {
-		return nil, errors.New("peer management system does not support this operation")
-	}
-
-	if len(seeds) == 0 {
-		return &coretypes.ResultDialSeeds{}, fmt.Errorf("%w: no seeds provided", coretypes.ErrInvalidRequest)
-	}
-	env.Logger.Info("DialSeeds", "seeds", seeds)
-	if err := env.P2PPeers.DialPeersAsync(seeds); err != nil {
-		return &coretypes.ResultDialSeeds{}, err
-	}
-	return &coretypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil
-}
-
-// UnsafeDialPeers dials the given peers (comma-separated id@IP:PORT),
-// optionally making them persistent.
-func (env *Environment) UnsafeDialPeers(
-	ctx *rpctypes.Context,
-	peers []string,
-	persistent, unconditional, private bool) (*coretypes.ResultDialPeers, error) {
-
-	if env.P2PPeers == nil {
-		return nil, errors.New("peer management system does not support this operation")
-	}
-
-	if len(peers) == 0 {
-		return &coretypes.ResultDialPeers{}, fmt.Errorf("%w: no peers provided", coretypes.ErrInvalidRequest)
-	}
-
-	ids, err := getIDs(peers)
-	if err != nil {
-		return &coretypes.ResultDialPeers{}, err
-	}
-
-	env.Logger.Info("DialPeers", "peers", peers, "persistent",
-		persistent, "unconditional", unconditional, "private", private)
-
-	if persistent {
-		if err := env.P2PPeers.AddPersistentPeers(peers); err != nil {
-			return &coretypes.ResultDialPeers{}, err
-		}
-	}
-
-	if private {
-		if err := env.P2PPeers.AddPrivatePeerIDs(ids); err != nil {
-			return &coretypes.ResultDialPeers{}, err
-		}
-	}
-
-	if unconditional {
-		if err := env.P2PPeers.AddUnconditionalPeerIDs(ids); err != nil {
-			return &coretypes.ResultDialPeers{}, err
-		}
-	}
-
-	if err := env.P2PPeers.DialPeersAsync(peers); err != nil {
-		return &coretypes.ResultDialPeers{}, err
-	}
-
-	return &coretypes.ResultDialPeers{Log: "Dialing peers in progress. See /net_info for details"}, nil
-}
-
 // Genesis returns genesis file.
 // More: https://docs.tendermint.com/master/rpc/#/Info/genesis
 func (env *Environment) Genesis(ctx *rpctypes.Context) (*coretypes.ResultGenesis, error) {
@@ -145,18 +65,3 @@ func (env *Environment) GenesisChunked(ctx *rpctypes.Context, chunk uint) (*core
 		Data:        env.genChunks[id],
 	}, nil
 }
-
-func getIDs(peers []string) ([]string, error) {
-	ids := make([]string, 0, len(peers))
-
-	for _, peer := range peers {
-
-		spl := strings.Split(peer, "@")
-		if len(spl) != 2 {
-			return nil, p2p.ErrNetAddressNoID{Addr: peer}
-		}
-		ids = append(ids, spl[0])
-
-	}
-	return ids, nil
-}
diff --git a/internal/rpc/core/net_test.go b/internal/rpc/core/net_test.go
deleted file mode 100644
index 7c12a69d6d..0000000000
--- a/internal/rpc/core/net_test.go
+++ /dev/null
@@ -1,89 +0,0 @@
-package core
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/libs/log"
-	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
-)
-
-func TestUnsafeDialSeeds(t *testing.T) {
-	sw := p2p.MakeSwitch(config.DefaultP2PConfig(), 1, "testing", "123.123.123",
-		func(n int, sw *p2p.Switch) *p2p.Switch { return sw }, log.TestingLogger())
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	env := &Environment{}
-	env.Logger = log.TestingLogger()
-	env.P2PPeers = sw
-
-	testCases := []struct {
-		seeds []string
-		isErr bool
-	}{
-		{[]string{}, true},
-		{[]string{"d51fb70907db1c6c2d5237e78379b25cf1a37ab4@127.0.0.1:41198"}, false},
-		{[]string{"127.0.0.1:41198"}, true},
-	}
-
-	for _, tc := range testCases {
-		res, err := env.UnsafeDialSeeds(&rpctypes.Context{}, tc.seeds)
-		if tc.isErr {
-			assert.Error(t, err)
-		} else {
-			assert.NoError(t, err)
-			assert.NotNil(t, res)
-		}
-	}
-}
-
-func TestUnsafeDialPeers(t *testing.T) {
-	sw := p2p.MakeSwitch(config.DefaultP2PConfig(), 1, "testing", "123.123.123",
-		func(n int, sw *p2p.Switch) *p2p.Switch { return sw }, log.TestingLogger())
-	sw.SetAddrBook(&p2p.AddrBookMock{
-		Addrs:        make(map[string]struct{}),
-		OurAddrs:     make(map[string]struct{}),
-		PrivateAddrs: make(map[string]struct{}),
-	})
-	err := sw.Start()
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		if err := sw.Stop(); err != nil {
-			t.Error(err)
-		}
-	})
-
-	env := &Environment{}
-	env.Logger = log.TestingLogger()
-	env.P2PPeers = sw
-
-	testCases := []struct {
-		peers                               []string
-		persistence, unconditional, private bool
-		isErr                               bool
-	}{
-		{[]string{}, false, false, false, true},
-		{[]string{"d51fb70907db1c6c2d5237e78379b25cf1a37ab4@127.0.0.1:41198"}, true, true, true, false},
-		{[]string{"127.0.0.1:41198"}, true, true, false, true},
-	}
-
-	for _, tc := range testCases {
-		res, err := env.UnsafeDialPeers(&rpctypes.Context{}, tc.peers, tc.persistence, tc.unconditional, tc.private)
-		if tc.isErr {
-			assert.Error(t, err)
-		} else {
-			assert.NoError(t, err)
-			assert.NotNil(t, res)
-		}
-	}
-}
diff --git a/internal/rpc/core/routes.go b/internal/rpc/core/routes.go
index 1eb50fe4e4..73eaaf14c1 100644
--- a/internal/rpc/core/routes.go
+++ b/internal/rpc/core/routes.go
@@ -55,7 +55,5 @@ func (env *Environment) GetRoutes() RoutesMap {
 // AddUnsafeRoutes adds unsafe routes.
 func (env *Environment) AddUnsafe(routes RoutesMap) {
 	// control API
-	routes["dial_seeds"] = rpc.NewRPCFunc(env.UnsafeDialSeeds, "seeds", false)
-	routes["dial_peers"] = rpc.NewRPCFunc(env.UnsafeDialPeers, "peers,persistent,unconditional,private", false)
 	routes["unsafe_flush_mempool"] = rpc.NewRPCFunc(env.UnsafeFlushMempool, "", false)
 }
diff --git a/internal/rpc/core/status.go b/internal/rpc/core/status.go
index bdd7ee1fa1..b883c6dc21 100644
--- a/internal/rpc/core/status.go
+++ b/internal/rpc/core/status.go
@@ -58,6 +58,7 @@ func (env *Environment) Status(ctx *rpctypes.Context) (*coretypes.ResultStatus,
 			VotingPower: votingPower,
 		}
 	}
+
 	result := &coretypes.ResultStatus{
 		NodeInfo: env.P2PTransport.NodeInfo(),
 		SyncInfo: coretypes.SyncInfo{
diff --git a/node/node.go b/node/node.go
index 820e0630aa..891c5fce65 100644
--- a/node/node.go
+++ b/node/node.go
@@ -54,10 +54,8 @@ type nodeImpl struct {
 
 	// network
 	transport   *p2p.MConnTransport
-	sw          *p2p.Switch // p2p connections
 	peerManager *p2p.PeerManager
 	router      *p2p.Router
-	addrBook    pex.AddrBook // known peers
 	nodeInfo    types.NodeInfo
 	nodeKey     types.NodeKey // our node privkey
 	isListening bool
@@ -292,14 +290,6 @@ func makeNode(cfg *config.Config,
 		return nil, fmt.Errorf("could not create blockchain reactor: %w", err)
 	}
 
-	// TODO: Remove this once the switch is removed.
-	var bcReactorForSwitch p2p.Reactor
-	if bcReactorShim != nil {
-		bcReactorForSwitch = bcReactorShim
-	} else {
-		bcReactorForSwitch = bcReactor.(p2p.Reactor)
-	}
-
 	// Make ConsensusReactor. Don't enable fully if doing a state sync and/or block sync first.
 	// FIXME We need to update metrics here, since other reactors don't have access to them.
 	if stateSync {
@@ -312,29 +302,15 @@ func makeNode(cfg *config.Config,
 	// FIXME The way we do phased startups (e.g. replay -> block sync -> consensus) is very messy,
 	// we should clean this whole thing up. See:
 	// https://github.com/tendermint/tendermint/issues/4644
-	var (
-		stateSyncReactor     *statesync.Reactor
-		stateSyncReactorShim *p2p.ReactorShim
-
-		channels    map[p2p.ChannelID]*p2p.Channel
-		peerUpdates *p2p.PeerUpdates
-	)
-
-	stateSyncReactorShim = p2p.NewReactorShim(logger.With("module", "statesync"), "StateSyncShim", statesync.ChannelShims)
-
-	if cfg.P2P.UseLegacy {
-		channels = getChannelsFromShim(stateSyncReactorShim)
-		peerUpdates = stateSyncReactorShim.PeerUpdates
-	} else {
-		channels = makeChannelsFromShims(router, statesync.ChannelShims)
-		peerUpdates = peerManager.Subscribe()
-	}
-
-	stateSyncReactor = statesync.NewReactor(
+	ssLogger := logger.With("module", "statesync")
+	ssReactorShim := p2p.NewReactorShim(ssLogger, "StateSyncShim", statesync.ChannelShims)
+	channels := makeChannelsFromShims(router, statesync.ChannelShims)
+	peerUpdates := peerManager.Subscribe()
+	stateSyncReactor := statesync.NewReactor(
 		genDoc.ChainID,
 		genDoc.InitialHeight,
 		*cfg.StateSync,
-		stateSyncReactorShim.Logger,
+		ssLogger,
 		proxyApp.Snapshot(),
 		proxyApp.Query(),
 		channels[statesync.SnapshotChannel],
@@ -353,10 +329,10 @@ func makeNode(cfg *config.Config,
 	// transports can either be agnostic to channel descriptors or can be
 	// declared in the constructor.
 	transport.AddChannelDescriptors(mpReactorShim.GetChannels())
-	transport.AddChannelDescriptors(bcReactorForSwitch.GetChannels())
+	transport.AddChannelDescriptors(bcReactorShim.GetChannels())
 	transport.AddChannelDescriptors(csReactorShim.GetChannels())
 	transport.AddChannelDescriptors(evReactorShim.GetChannels())
-	transport.AddChannelDescriptors(stateSyncReactorShim.GetChannels())
+	transport.AddChannelDescriptors(ssReactorShim.GetChannels())
 
 	// Optionally, start the pex reactor
 	//
@@ -371,44 +347,14 @@ func makeNode(cfg *config.Config,
 	// If PEX is on, it should handle dialing the seeds. Otherwise the switch does it.
 	// Note we currently use the addrBook regardless at least for AddOurAddress
 
-	var (
-		pexReactor service.Service
-		sw         *p2p.Switch
-		addrBook   pex.AddrBook
-	)
+	var pexReactor service.Service
 
 	pexCh := pex.ChannelDescriptor()
 	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
 
-	if cfg.P2P.UseLegacy {
-		// setup Transport and Switch
-		sw = createSwitch(
-			cfg, transport, nodeMetrics.p2p, mpReactorShim, bcReactorForSwitch,
-			stateSyncReactorShim, csReactorShim, evReactorShim, proxyApp, nodeInfo, nodeKey, p2pLogger,
-		)
-
-		err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(cfg.P2P.PersistentPeers, ",", " "))
-		if err != nil {
-			return nil, fmt.Errorf("could not add peers from persistent-peers field: %w", err)
-		}
-
-		err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(cfg.P2P.UnconditionalPeerIDs, ",", " "))
-		if err != nil {
-			return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err)
-		}
-
-		addrBook, err = createAddrBookAndSetOnSwitch(cfg, sw, p2pLogger, nodeKey)
-		if err != nil {
-			return nil, fmt.Errorf("could not create addrbook: %w", err)
-		}
-
-		pexReactor = createPEXReactorAndAddToSwitch(addrBook, cfg, sw, logger)
-	} else {
-		addrBook = nil
-		pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router)
-		if err != nil {
-			return nil, err
-		}
+	pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router)
+	if err != nil {
+		return nil, err
 	}
 
 	if cfg.RPC.PprofListenAddress != "" {
@@ -424,10 +370,8 @@ func makeNode(cfg *config.Config,
 		privValidator: privValidator,
 
 		transport:   transport,
-		sw:          sw,
 		peerManager: peerManager,
 		router:      router,
-		addrBook:    addrBook,
 		nodeInfo:    nodeInfo,
 		nodeKey:     nodeKey,
 
@@ -456,7 +400,6 @@ func makeNode(cfg *config.Config,
 			ConsensusReactor: csReactor,
 			BlockSyncReactor: bcReactor.(consensus.BlockSyncReactor),
 
-			P2PPeers:    sw,
 			PeerManager: peerManager,
 
 			GenDoc:     genDoc,
@@ -468,17 +411,6 @@ func makeNode(cfg *config.Config,
 		},
 	}
 
-	// this is a terrible, because typed nil interfaces are not ==
-	// nil, so this is just cleanup to avoid having a non-nil
-	// value in the RPC environment that has the semantic
-	// properties of nil.
-	if sw == nil {
-		node.rpcEnv.P2PPeers = nil
-	} else if peerManager == nil {
-		node.rpcEnv.PeerManager = nil
-	}
-	// end hack
-
 	node.rpcEnv.P2PTransport = node
 
 	node.BaseService = *service.NewBaseService(logger, "Node", node)
@@ -525,11 +457,7 @@ func makeSeedNode(cfg *config.Config,
 		return nil, fmt.Errorf("failed to create router: %w", err)
 	}
 
-	var (
-		pexReactor service.Service
-		sw         *p2p.Switch
-		addrBook   pex.AddrBook
-	)
+	var pexReactor service.Service
 
 	// add the pex reactor
 	// FIXME: we add channel descriptors to both the router and the transport but only the router
@@ -538,33 +466,9 @@ func makeSeedNode(cfg *config.Config,
 	pexCh := pex.ChannelDescriptor()
 	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
 
-	if cfg.P2P.UseLegacy {
-		sw = createSwitch(
-			cfg, transport, p2pMetrics, nil, nil,
-			nil, nil, nil, nil, nodeInfo, nodeKey, p2pLogger,
-		)
-
-		err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(cfg.P2P.PersistentPeers, ",", " "))
-		if err != nil {
-			return nil, fmt.Errorf("could not add peers from persistent_peers field: %w", err)
-		}
-
-		err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(cfg.P2P.UnconditionalPeerIDs, ",", " "))
-		if err != nil {
-			return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err)
-		}
-
-		addrBook, err = createAddrBookAndSetOnSwitch(cfg, sw, p2pLogger, nodeKey)
-		if err != nil {
-			return nil, fmt.Errorf("could not create addrbook: %w", err)
-		}
-
-		pexReactor = createPEXReactorAndAddToSwitch(addrBook, cfg, sw, logger)
-	} else {
-		pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router)
-		if err != nil {
-			return nil, err
-		}
+	pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router)
+	if err != nil {
+		return nil, err
 	}
 
 	if cfg.RPC.PprofListenAddress != "" {
@@ -579,8 +483,6 @@ func makeSeedNode(cfg *config.Config,
 		genesisDoc: genDoc,
 
 		transport:   transport,
-		sw:          sw,
-		addrBook:    addrBook,
 		nodeInfo:    nodeInfo,
 		nodeKey:     nodeKey,
 		peerManager: peerManager,
@@ -627,15 +529,8 @@ func (n *nodeImpl) OnStart() error {
 	}
 
 	n.isListening = true
-	n.Logger.Info("p2p service", "legacy_enabled", n.config.P2P.UseLegacy)
 
-	if n.config.P2P.UseLegacy {
-		// Add private IDs to addrbook to block those peers being added
-		n.addrBook.AddPrivateIDs(strings.SplitAndTrimEmpty(n.config.P2P.PrivatePeerIDs, ",", " "))
-		if err = n.sw.Start(); err != nil {
-			return err
-		}
-	} else if err = n.router.Start(); err != nil {
+	if err = n.router.Start(); err != nil {
 		return err
 	}
 
@@ -667,13 +562,7 @@ func (n *nodeImpl) OnStart() error {
 		}
 	}
 
-	if n.config.P2P.UseLegacy {
-		// Always connect to persistent peers
-		err = n.sw.DialPeersAsync(strings.SplitAndTrimEmpty(n.config.P2P.PersistentPeers, ",", " "))
-		if err != nil {
-			return fmt.Errorf("could not dial peers from persistent-peers field: %w", err)
-		}
-	} else if err := n.pexReactor.Start(); err != nil {
+	if err := n.pexReactor.Start(); err != nil {
 		return err
 	}
 
@@ -794,14 +683,8 @@ func (n *nodeImpl) OnStop() {
 		n.Logger.Error("failed to stop the PEX v2 reactor", "err", err)
 	}
 
-	if n.config.P2P.UseLegacy {
-		if err := n.sw.Stop(); err != nil {
-			n.Logger.Error("failed to stop switch", "err", err)
-		}
-	} else {
-		if err := n.router.Stop(); err != nil {
-			n.Logger.Error("failed to stop router", "err", err)
-		}
+	if err := n.router.Stop(); err != nil {
+		n.Logger.Error("failed to stop router", "err", err)
 	}
 
 	if err := n.transport.Close(); err != nil {
@@ -1216,12 +1099,3 @@ func makeChannelsFromShims(
 
 	return channels
 }
-
-func getChannelsFromShim(reactorShim *p2p.ReactorShim) map[p2p.ChannelID]*p2p.Channel {
-	channels := map[p2p.ChannelID]*p2p.Channel{}
-	for chID := range reactorShim.Channels {
-		channels[chID] = reactorShim.GetChannel(chID)
-	}
-
-	return channels
-}
diff --git a/node/setup.go b/node/setup.go
index 16aa715c9b..8889edc4ea 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -2,16 +2,13 @@ package node
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"math"
-	"net"
 	"time"
 
 	dbm "github.com/tendermint/tm-db"
 
 	abciclient "github.com/tendermint/tendermint/abci/client"
-	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
 	bcv0 "github.com/tendermint/tendermint/internal/blocksync/v0"
@@ -161,18 +158,8 @@ func createMempoolReactor(
 	channelShims := mempoolv0.GetChannelShims(cfg.Mempool)
 	reactorShim := p2p.NewReactorShim(logger, "MempoolShim", channelShims)
 
-	var (
-		channels    map[p2p.ChannelID]*p2p.Channel
-		peerUpdates *p2p.PeerUpdates
-	)
-
-	if cfg.P2P.UseLegacy {
-		channels = getChannelsFromShim(reactorShim)
-		peerUpdates = reactorShim.PeerUpdates
-	} else {
-		channels = makeChannelsFromShims(router, channelShims)
-		peerUpdates = peerManager.Subscribe()
-	}
+	channels := makeChannelsFromShims(router, channelShims)
+	peerUpdates := peerManager.Subscribe()
 
 	switch cfg.Mempool.Version {
 	case config.MempoolV0:
@@ -255,23 +242,10 @@ func createEvidenceReactor(
 		return nil, nil, nil, fmt.Errorf("creating evidence pool: %w", err)
 	}
 
-	var (
-		channels    map[p2p.ChannelID]*p2p.Channel
-		peerUpdates *p2p.PeerUpdates
-	)
-
-	if cfg.P2P.UseLegacy {
-		channels = getChannelsFromShim(reactorShim)
-		peerUpdates = reactorShim.PeerUpdates
-	} else {
-		channels = makeChannelsFromShims(router, evidence.ChannelShims)
-		peerUpdates = peerManager.Subscribe()
-	}
-
 	evidenceReactor := evidence.NewReactor(
 		logger,
-		channels[evidence.EvidenceChannel],
-		peerUpdates,
+		makeChannelsFromShims(router, evidence.ChannelShims)[evidence.EvidenceChannel],
+		peerManager.Subscribe(),
 		evidencePool,
 	)
 
@@ -294,19 +268,8 @@ func createBlockchainReactor(
 	logger = logger.With("module", "blockchain")
 
 	reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", bcv0.ChannelShims)
-
-	var (
-		channels    map[p2p.ChannelID]*p2p.Channel
-		peerUpdates *p2p.PeerUpdates
-	)
-
-	if cfg.P2P.UseLegacy {
-		channels = getChannelsFromShim(reactorShim)
-		peerUpdates = reactorShim.PeerUpdates
-	} else {
-		channels = makeChannelsFromShims(router, bcv0.ChannelShims)
-		peerUpdates = peerManager.Subscribe()
-	}
+	channels := makeChannelsFromShims(router, bcv0.ChannelShims)
+	peerUpdates := peerManager.Subscribe()
 
 	reactor, err := bcv0.NewReactor(
 		logger, state.Copy(), blockExec, blockStore, csReactor,
@@ -357,13 +320,8 @@ func createConsensusReactor(
 		peerUpdates *p2p.PeerUpdates
 	)
 
-	if cfg.P2P.UseLegacy {
-		channels = getChannelsFromShim(reactorShim)
-		peerUpdates = reactorShim.PeerUpdates
-	} else {
-		channels = makeChannelsFromShims(router, consensus.ChannelShims)
-		peerUpdates = peerManager.Subscribe()
-	}
+	channels = makeChannelsFromShims(router, consensus.ChannelShims)
+	peerUpdates = peerManager.Subscribe()
 
 	reactor := consensus.NewReactor(
 		logger,
@@ -500,142 +458,6 @@ func createRouter(
 	)
 }
 
-func createSwitch(
-	cfg *config.Config,
-	transport p2p.Transport,
-	p2pMetrics *p2p.Metrics,
-	mempoolReactor *p2p.ReactorShim,
-	bcReactor p2p.Reactor,
-	stateSyncReactor *p2p.ReactorShim,
-	consensusReactor *p2p.ReactorShim,
-	evidenceReactor *p2p.ReactorShim,
-	proxyApp proxy.AppConns,
-	nodeInfo types.NodeInfo,
-	nodeKey types.NodeKey,
-	p2pLogger log.Logger,
-) *p2p.Switch {
-
-	var (
-		connFilters = []p2p.ConnFilterFunc{}
-		peerFilters = []p2p.PeerFilterFunc{}
-	)
-
-	if !cfg.P2P.AllowDuplicateIP {
-		connFilters = append(connFilters, p2p.ConnDuplicateIPFilter)
-	}
-
-	// Filter peers by addr or pubkey with an ABCI query.
-	// If the query return code is OK, add peer.
-	if cfg.FilterPeers {
-		connFilters = append(
-			connFilters,
-			// ABCI query for address filtering.
-			func(_ p2p.ConnSet, c net.Conn, _ []net.IP) error {
-				res, err := proxyApp.Query().QuerySync(context.Background(), abci.RequestQuery{
-					Path: fmt.Sprintf("/p2p/filter/addr/%s", c.RemoteAddr().String()),
-				})
-				if err != nil {
-					return err
-				}
-				if res.IsErr() {
-					return fmt.Errorf("error querying abci app: %v", res)
-				}
-
-				return nil
-			},
-		)
-
-		peerFilters = append(
-			peerFilters,
-			// ABCI query for ID filtering.
-			func(_ p2p.IPeerSet, p p2p.Peer) error {
-				res, err := proxyApp.Query().QuerySync(context.Background(), abci.RequestQuery{
-					Path: fmt.Sprintf("/p2p/filter/id/%s", p.ID()),
-				})
-				if err != nil {
-					return err
-				}
-				if res.IsErr() {
-					return fmt.Errorf("error querying abci app: %v", res)
-				}
-
-				return nil
-			},
-		)
-	}
-
-	sw := p2p.NewSwitch(
-		cfg.P2P,
-		transport,
-		p2p.WithMetrics(p2pMetrics),
-		p2p.SwitchPeerFilters(peerFilters...),
-		p2p.SwitchConnFilters(connFilters...),
-	)
-
-	sw.SetLogger(p2pLogger)
-	if cfg.Mode != config.ModeSeed {
-		sw.AddReactor("MEMPOOL", mempoolReactor)
-		sw.AddReactor("BLOCKCHAIN", bcReactor)
-		sw.AddReactor("CONSENSUS", consensusReactor)
-		sw.AddReactor("EVIDENCE", evidenceReactor)
-		sw.AddReactor("STATESYNC", stateSyncReactor)
-	}
-
-	sw.SetNodeInfo(nodeInfo)
-	sw.SetNodeKey(nodeKey)
-
-	p2pLogger.Info("P2P Node ID", "ID", nodeKey.ID, "file", cfg.NodeKeyFile())
-	return sw
-}
-
-func createAddrBookAndSetOnSwitch(cfg *config.Config, sw *p2p.Switch,
-	p2pLogger log.Logger, nodeKey types.NodeKey) (pex.AddrBook, error) {
-
-	addrBook := pex.NewAddrBook(cfg.P2P.AddrBookFile(), cfg.P2P.AddrBookStrict)
-	addrBook.SetLogger(p2pLogger.With("book", cfg.P2P.AddrBookFile()))
-
-	// Add ourselves to addrbook to prevent dialing ourselves
-	if cfg.P2P.ExternalAddress != "" {
-		addr, err := types.NewNetAddressString(nodeKey.ID.AddressString(cfg.P2P.ExternalAddress))
-		if err != nil {
-			return nil, fmt.Errorf("p2p.external_address is incorrect: %w", err)
-		}
-		addrBook.AddOurAddress(addr)
-	}
-	if cfg.P2P.ListenAddress != "" {
-		addr, err := types.NewNetAddressString(nodeKey.ID.AddressString(cfg.P2P.ListenAddress))
-		if err != nil {
-			return nil, fmt.Errorf("p2p.laddr is incorrect: %w", err)
-		}
-		addrBook.AddOurAddress(addr)
-	}
-
-	sw.SetAddrBook(addrBook)
-
-	return addrBook, nil
-}
-
-func createPEXReactorAndAddToSwitch(addrBook pex.AddrBook, cfg *config.Config,
-	sw *p2p.Switch, logger log.Logger) *pex.Reactor {
-
-	reactorConfig := &pex.ReactorConfig{
-		Seeds:    tmstrings.SplitAndTrimEmpty(cfg.P2P.Seeds, ",", " "),
-		SeedMode: cfg.Mode == config.ModeSeed,
-		// See consensus/reactor.go: blocksToContributeToBecomeGoodPeer 10000
-		// blocks assuming 10s blocks ~ 28 hours.
-		// TODO (melekes): make it dynamic based on the actual block latencies
-		// from the live network.
-		// https://github.com/tendermint/tendermint/issues/3523
-		SeedDisconnectWaitPeriod:     28 * time.Hour,
-		PersistentPeersMaxDialPeriod: cfg.P2P.PersistentPeersMaxDialPeriod,
-	}
-	// TODO persistent peers ? so we can have their DNS addrs saved
-	pexReactor := pex.NewReactor(addrBook, reactorConfig)
-	pexReactor.SetLogger(logger.With("module", "pex"))
-	sw.AddReactor("PEX", pexReactor)
-	return pexReactor
-}
-
 func createPEXReactorV2(
 	cfg *config.Config,
 	logger log.Logger,
diff --git a/rpc/client/local/local.go b/rpc/client/local/local.go
index 85302691d5..108510b023 100644
--- a/rpc/client/local/local.go
+++ b/rpc/client/local/local.go
@@ -136,20 +136,6 @@ func (c *Local) Health(ctx context.Context) (*coretypes.ResultHealth, error) {
 	return c.env.Health(c.ctx)
 }
 
-func (c *Local) DialSeeds(ctx context.Context, seeds []string) (*coretypes.ResultDialSeeds, error) {
-	return c.env.UnsafeDialSeeds(c.ctx, seeds)
-}
-
-func (c *Local) DialPeers(
-	ctx context.Context,
-	peers []string,
-	persistent,
-	unconditional,
-	private bool,
-) (*coretypes.ResultDialPeers, error) {
-	return c.env.UnsafeDialPeers(c.ctx, peers, persistent, unconditional, private)
-}
-
 func (c *Local) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { //nolint:lll
 	return c.env.BlockchainInfo(c.ctx, minHeight, maxHeight)
 }
diff --git a/rpc/client/mock/client.go b/rpc/client/mock/client.go
index 4b858d067c..a1a42e28db 100644
--- a/rpc/client/mock/client.go
+++ b/rpc/client/mock/client.go
@@ -131,20 +131,6 @@ func (c Client) Health(ctx context.Context) (*coretypes.ResultHealth, error) {
 	return c.env.Health(&rpctypes.Context{})
 }
 
-func (c Client) DialSeeds(ctx context.Context, seeds []string) (*coretypes.ResultDialSeeds, error) {
-	return c.env.UnsafeDialSeeds(&rpctypes.Context{}, seeds)
-}
-
-func (c Client) DialPeers(
-	ctx context.Context,
-	peers []string,
-	persistent,
-	unconditional,
-	private bool,
-) (*coretypes.ResultDialPeers, error) {
-	return c.env.UnsafeDialPeers(&rpctypes.Context{}, peers, persistent, unconditional, private)
-}
-
 func (c Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { //nolint:lll
 	return c.env.BlockchainInfo(&rpctypes.Context{}, minHeight, maxHeight)
 }
diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index deffb533a7..5c47faa23d 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -15,7 +15,6 @@ var (
 	// separate testnet for each combination (Cartesian product) of options.
 	testnetCombinations = map[string][]interface{}{
 		"topology":      {"single", "quad", "large"},
-		"p2p":           {NewP2PMode, LegacyP2PMode, HybridP2PMode},
 		"queueType":     {"priority"}, // "fifo", "wdrr"
 		"initialHeight": {0, 1000},
 		"initialState": {
@@ -71,19 +70,6 @@ var (
 // Generate generates random testnets using the given RNG.
 func Generate(r *rand.Rand, opts Options) ([]e2e.Manifest, error) {
 	manifests := []e2e.Manifest{}
-	switch opts.P2P {
-	case NewP2PMode, LegacyP2PMode, HybridP2PMode:
-		defer func() {
-			// avoid modifying the global state.
-			original := make([]interface{}, len(testnetCombinations["p2p"]))
-			copy(original, testnetCombinations["p2p"])
-			testnetCombinations["p2p"] = original
-		}()
-
-		testnetCombinations["p2p"] = []interface{}{opts.P2P}
-	case MixedP2PMode:
-		testnetCombinations["p2p"] = []interface{}{NewP2PMode, LegacyP2PMode, HybridP2PMode}
-	}
 
 	for _, opt := range combinations(testnetCombinations) {
 		manifest, err := generateTestnet(r, opt)
@@ -95,12 +81,6 @@ func Generate(r *rand.Rand, opts Options) ([]e2e.Manifest, error) {
 			continue
 		}
 
-		if len(manifest.Nodes) == 1 {
-			if opt["p2p"] == HybridP2PMode {
-				continue
-			}
-		}
-
 		if opts.MaxNetworkSize > 0 && len(manifest.Nodes) >= opts.MaxNetworkSize {
 			continue
 		}
@@ -116,20 +96,9 @@ type Options struct {
 	MaxNetworkSize int
 	NumGroups      int
 	Directory      string
-	P2P            P2PMode
 	Reverse        bool
 }
 
-type P2PMode string
-
-const (
-	NewP2PMode    P2PMode = "new"
-	LegacyP2PMode P2PMode = "legacy"
-	HybridP2PMode P2PMode = "hybrid"
-	// mixed means that all combination are generated
-	MixedP2PMode P2PMode = "mixed"
-)
-
 // generateTestnet generates a single testnet with the given options.
 func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, error) {
 	manifest := e2e.Manifest{
@@ -145,13 +114,6 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 		TxSize:           int64(txSize.Choose(r).(int)),
 	}
 
-	p2pMode := opt["p2p"].(P2PMode)
-	switch p2pMode {
-	case NewP2PMode, LegacyP2PMode, HybridP2PMode:
-	default:
-		return manifest, fmt.Errorf("unknown p2p mode %s", p2pMode)
-	}
-
 	var numSeeds, numValidators, numFulls, numLightClients int
 	switch opt["topology"].(string) {
 	case "single":
@@ -168,27 +130,13 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 		return manifest, fmt.Errorf("unknown topology %q", opt["topology"])
 	}
 
-	const legacyP2PFactor float64 = 0.5
-
 	// First we generate seed nodes, starting at the initial height.
 	for i := 1; i <= numSeeds; i++ {
 		node := generateNode(r, manifest, e2e.ModeSeed, 0, false)
-
-		switch p2pMode {
-		case LegacyP2PMode:
-			node.UseLegacyP2P = true
-		case HybridP2PMode:
-			node.UseLegacyP2P = r.Float64() < legacyP2PFactor
-		}
-
 		manifest.Nodes[fmt.Sprintf("seed%02d", i)] = node
 	}
 
-	var (
-		numSyncingNodes = 0
-		hybridNumNew    = 0
-		hybridNumLegacy = 0
-	)
+	var numSyncingNodes = 0
 
 	// Next, we generate validators. We make sure a BFT quorum of validators start
 	// at the initial height, and that we have two archive nodes. We also set up
@@ -205,29 +153,6 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 		name := fmt.Sprintf("validator%02d", i)
 		node := generateNode(r, manifest, e2e.ModeValidator, startAt, i <= 2)
 
-		switch p2pMode {
-		case LegacyP2PMode:
-			node.UseLegacyP2P = true
-		case HybridP2PMode:
-			node.UseLegacyP2P = r.Float64() < legacyP2PFactor
-			if node.UseLegacyP2P {
-				hybridNumLegacy++
-				if hybridNumNew == 0 {
-					hybridNumNew++
-					hybridNumLegacy--
-					node.UseLegacyP2P = false
-				}
-			} else {
-				hybridNumNew++
-				if hybridNumLegacy == 0 {
-					hybridNumNew--
-					hybridNumLegacy++
-					node.UseLegacyP2P = true
-
-				}
-			}
-		}
-
 		manifest.Nodes[name] = node
 
 		if startAt == 0 {
@@ -259,13 +184,6 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 		}
 		node := generateNode(r, manifest, e2e.ModeFull, startAt, false)
 
-		switch p2pMode {
-		case LegacyP2PMode:
-			node.UseLegacyP2P = true
-		case HybridP2PMode:
-			node.UseLegacyP2P = r.Float64() > legacyP2PFactor
-		}
-
 		manifest.Nodes[fmt.Sprintf("full%02d", i)] = node
 	}
 
@@ -336,13 +254,6 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 			r, startAt+(5*int64(i)), lightProviders,
 		)
 
-		switch p2pMode {
-		case LegacyP2PMode:
-			node.UseLegacyP2P = true
-		case HybridP2PMode:
-			node.UseLegacyP2P = r.Float64() < legacyP2PFactor
-		}
-
 		manifest.Nodes[fmt.Sprintf("light%02d", i)] = node
 
 	}
diff --git a/test/e2e/generator/generate_test.go b/test/e2e/generator/generate_test.go
index c38b6b20bc..b7f7902590 100644
--- a/test/e2e/generator/generate_test.go
+++ b/test/e2e/generator/generate_test.go
@@ -5,15 +5,14 @@ import (
 	"math/rand"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	e2e "github.com/tendermint/tendermint/test/e2e/pkg"
 )
 
 func TestGenerator(t *testing.T) {
-	manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), Options{P2P: MixedP2PMode})
+	manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), Options{})
 	require.NoError(t, err)
-	require.True(t, len(manifests) >= 64, "insufficient combinations")
+	require.True(t, len(manifests) >= 24, "insufficient combinations %d", len(manifests))
 
 	// this just means that the numbers reported by the test
 	// failures map to the test cases that you'd see locally.
@@ -41,71 +40,4 @@ func TestGenerator(t *testing.T) {
 			require.True(t, numStateSyncs <= 2)
 		})
 	}
-
-	t.Run("Hybrid", func(t *testing.T) {
-		manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), Options{P2P: HybridP2PMode})
-		require.NoError(t, err)
-		require.True(t, len(manifests) >= 16, "insufficient combinations: %d", len(manifests))
-
-		// failures map to the test cases that you'd see locally.
-		e2e.SortManifests(manifests, false /* ascending */)
-
-		for idx, m := range manifests {
-			t.Run(fmt.Sprintf("Case%04d", idx), func(t *testing.T) {
-				require.True(t, len(m.Nodes) > 1)
-
-				var numLegacy, numNew int
-				for _, node := range m.Nodes {
-					if node.UseLegacyP2P {
-						numLegacy++
-					} else {
-						numNew++
-					}
-				}
-
-				assert.True(t, numLegacy >= 1, "not enough legacy nodes [%d/%d]",
-					numLegacy, len(m.Nodes))
-				assert.True(t, numNew >= 1, "not enough new nodes [%d/%d]",
-					numNew, len(m.Nodes))
-			})
-		}
-	})
-	t.Run("UnmixedP2P", func(t *testing.T) {
-		t.Run("New", func(t *testing.T) {
-			manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), Options{P2P: NewP2PMode})
-			require.NoError(t, err)
-			require.True(t, len(manifests) >= 16, "insufficient combinations: %d", len(manifests))
-
-			// failures map to the test cases that you'd see locally.
-			e2e.SortManifests(manifests, false /* ascending */)
-
-			for idx, m := range manifests {
-				t.Run(fmt.Sprintf("Case%04d", idx), func(t *testing.T) {
-					for name, node := range m.Nodes {
-						t.Run(name, func(t *testing.T) {
-							require.False(t, node.UseLegacyP2P)
-						})
-					}
-				})
-			}
-		})
-		t.Run("Legacy", func(t *testing.T) {
-			manifests, err := Generate(rand.New(rand.NewSource(randomSeed)), Options{P2P: LegacyP2PMode})
-			require.NoError(t, err)
-			require.True(t, len(manifests) >= 16, "insufficient combinations: %d", len(manifests))
-
-			// failures map to the test cases that you'd see locally.
-			e2e.SortManifests(manifests, false /* ascending */)
-
-			for idx, m := range manifests {
-				t.Run(fmt.Sprintf("Case%04d", idx), func(t *testing.T) {
-					for name, node := range m.Nodes {
-						t.Run(name, func(t *testing.T) {
-							require.True(t, node.UseLegacyP2P)
-						})
-					}
-				})
-			}
-		})
-	})
 }
diff --git a/test/e2e/generator/main.go b/test/e2e/generator/main.go
index 4668f6a8f7..38f36d0dac 100644
--- a/test/e2e/generator/main.go
+++ b/test/e2e/generator/main.go
@@ -38,20 +38,6 @@ func NewCLI() *CLI {
 		SilenceUsage:  true,
 		SilenceErrors: true, // we'll output them ourselves in Run()
 		RunE: func(cmd *cobra.Command, args []string) error {
-			var err error
-
-			p2pMode, err := cmd.Flags().GetString("p2p")
-			if err != nil {
-				return err
-			}
-
-			switch mode := P2PMode(p2pMode); mode {
-			case NewP2PMode, LegacyP2PMode, HybridP2PMode, MixedP2PMode:
-				cli.opts.P2P = mode
-			default:
-				return fmt.Errorf("p2p mode must be either new, legacy, hybrid or mixed got %s", p2pMode)
-			}
-
 			return cli.generate()
 		},
 	}
@@ -60,8 +46,6 @@ func NewCLI() *CLI {
 	_ = cli.root.MarkPersistentFlagRequired("dir")
 	cli.root.Flags().BoolVarP(&cli.opts.Reverse, "reverse", "r", false, "Reverse sort order")
 	cli.root.PersistentFlags().IntVarP(&cli.opts.NumGroups, "groups", "g", 0, "Number of groups")
-	cli.root.PersistentFlags().StringP("p2p", "p", string(MixedP2PMode),
-		"P2P typology to be generated [\"new\", \"legacy\", \"hybrid\" or \"mixed\" ]")
 	cli.root.PersistentFlags().IntVarP(&cli.opts.MinNetworkSize, "min-size", "", 1,
 		"Minimum network size (nodes)")
 	cli.root.PersistentFlags().IntVarP(&cli.opts.MaxNetworkSize, "max-size", "", 0,
diff --git a/test/e2e/networks/ci.toml b/test/e2e/networks/ci.toml
index 6eb32e56fd..f73a188599 100644
--- a/test/e2e/networks/ci.toml
+++ b/test/e2e/networks/ci.toml
@@ -1,7 +1,6 @@
 # This testnet is run by CI, and attempts to cover a broad range of
 # functionality with a single network.
 
-disable_legacy_p2p = false
 evidence = 5
 initial_height = 1000
 initial_state = {initial01 = "a", initial02 = "b", initial03 = "c"}
diff --git a/test/e2e/pkg/manifest.go b/test/e2e/pkg/manifest.go
index 4492f40375..d5c9cb7f24 100644
--- a/test/e2e/pkg/manifest.go
+++ b/test/e2e/pkg/manifest.go
@@ -145,9 +145,6 @@ type ManifestNode struct {
 	// This is helpful when debugging a specific problem. This overrides the network
 	// level.
 	LogLevel string `toml:"log_level"`
-
-	// UseLegacyP2P enables use of the legacy p2p layer for this node.
-	UseLegacyP2P bool `toml:"use_legacy_p2p"`
 }
 
 // Stateless reports whether m is a node that does not own state, including light and seed nodes.
diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go
index b54dd2bf0c..3a75b169e6 100644
--- a/test/e2e/pkg/testnet.go
+++ b/test/e2e/pkg/testnet.go
@@ -96,7 +96,6 @@ type Node struct {
 	PersistentPeers  []*Node
 	Perturbations    []Perturbation
 	LogLevel         string
-	UseLegacyP2P     bool
 	QueueType        string
 	HasStarted       bool
 }
@@ -182,7 +181,6 @@ func LoadTestnet(file string) (*Testnet, error) {
 			Perturbations:    []Perturbation{},
 			LogLevel:         manifest.LogLevel,
 			QueueType:        manifest.QueueType,
-			UseLegacyP2P:     nodeManifest.UseLegacyP2P,
 		}
 
 		if node.StartAt == testnet.InitialHeight {
diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go
index 5a8407ab2c..3b1184e9ce 100644
--- a/test/e2e/runner/setup.go
+++ b/test/e2e/runner/setup.go
@@ -238,7 +238,6 @@ func MakeConfig(node *e2e.Node) (*config.Config, error) {
 	cfg.RPC.PprofListenAddress = ":6060"
 	cfg.P2P.ExternalAddress = fmt.Sprintf("tcp://%v", node.AddressP2P(false))
 	cfg.P2P.AddrBookStrict = false
-	cfg.P2P.UseLegacy = node.UseLegacyP2P
 	cfg.P2P.QueueType = node.QueueType
 	cfg.DBBackend = node.Database
 	cfg.StateSync.DiscoveryTime = 5 * time.Second
@@ -354,7 +353,6 @@ func MakeAppConfig(node *e2e.Node) ([]byte, error) {
 		"snapshot_interval": node.SnapshotInterval,
 		"retain_blocks":     node.RetainBlocks,
 		"key_type":          node.PrivvalKey.Type(),
-		"use_legacy_p2p":    node.UseLegacyP2P,
 	}
 	switch node.ABCIProtocol {
 	case e2e.ProtocolUNIX:
diff --git a/test/fuzz/p2p/addrbook/fuzz.go b/test/fuzz/p2p/addrbook/fuzz.go
deleted file mode 100644
index 6d5548fc73..0000000000
--- a/test/fuzz/p2p/addrbook/fuzz.go
+++ /dev/null
@@ -1,35 +0,0 @@
-// nolint: gosec
-package addrbook
-
-import (
-	"encoding/json"
-	"fmt"
-	"math/rand"
-
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/pex"
-)
-
-var addrBook = pex.NewAddrBook("./testdata/addrbook.json", true)
-
-func Fuzz(data []byte) int {
-	addr := new(p2p.NetAddress)
-	if err := json.Unmarshal(data, addr); err != nil {
-		return -1
-	}
-
-	// Fuzz AddAddress.
-	err := addrBook.AddAddress(addr, addr)
-	if err != nil {
-		return 0
-	}
-
-	// Also, make sure PickAddress always returns a non-nil address.
-	bias := rand.Intn(100)
-	if p := addrBook.PickAddress(bias); p == nil {
-		panic(fmt.Sprintf("picked a nil address (bias: %d, addrBook size: %v)",
-			bias, addrBook.Size()))
-	}
-
-	return 1
-}
diff --git a/test/fuzz/p2p/addrbook/fuzz_test.go b/test/fuzz/p2p/addrbook/fuzz_test.go
deleted file mode 100644
index 4ec7aebd98..0000000000
--- a/test/fuzz/p2p/addrbook/fuzz_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package addrbook_test
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"github.com/tendermint/tendermint/test/fuzz/p2p/addrbook"
-)
-
-const testdataCasesDir = "testdata/cases"
-
-func TestAddrbookTestdataCases(t *testing.T) {
-	entries, err := os.ReadDir(testdataCasesDir)
-	require.NoError(t, err)
-
-	for _, e := range entries {
-		entry := e
-		t.Run(entry.Name(), func(t *testing.T) {
-			defer func() {
-				r := recover()
-				require.Nilf(t, r, "testdata/cases test panic")
-			}()
-			f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name()))
-			require.NoError(t, err)
-			input, err := ioutil.ReadAll(f)
-			require.NoError(t, err)
-			addrbook.Fuzz(input)
-		})
-	}
-}
diff --git a/test/fuzz/p2p/addrbook/init-corpus/main.go b/test/fuzz/p2p/addrbook/init-corpus/main.go
deleted file mode 100644
index 1166f9bd74..0000000000
--- a/test/fuzz/p2p/addrbook/init-corpus/main.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// nolint: gosec
-package main
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net"
-	"os"
-	"path/filepath"
-
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/types"
-)
-
-func main() {
-	baseDir := flag.String("base", ".", `where the "corpus" directory will live`)
-	flag.Parse()
-
-	initCorpus(*baseDir)
-}
-
-func initCorpus(baseDir string) {
-	log.SetFlags(0)
-
-	// create "corpus" directory
-	corpusDir := filepath.Join(baseDir, "corpus")
-	if err := os.MkdirAll(corpusDir, 0755); err != nil {
-		log.Fatalf("Creating %q err: %v", corpusDir, err)
-	}
-
-	// create corpus
-	privKey := ed25519.GenPrivKey()
-	addrs := []*p2p.NetAddress{
-		{ID: types.NodeIDFromPubKey(privKey.PubKey()), IP: net.IPv4(0, 0, 0, 0), Port: 0},
-		{ID: types.NodeIDFromPubKey(privKey.PubKey()), IP: net.IPv4(127, 0, 0, 0), Port: 80},
-		{ID: types.NodeIDFromPubKey(privKey.PubKey()), IP: net.IPv4(213, 87, 10, 200), Port: 8808},
-		{ID: types.NodeIDFromPubKey(privKey.PubKey()), IP: net.IPv4(111, 111, 111, 111), Port: 26656},
-		{ID: types.NodeIDFromPubKey(privKey.PubKey()), IP: net.ParseIP("2001:db8::68"), Port: 26656},
-	}
-
-	for i, addr := range addrs {
-		filename := filepath.Join(corpusDir, fmt.Sprintf("%d.json", i))
-
-		bz, err := json.Marshal(addr)
-		if err != nil {
-			log.Fatalf("can't marshal %v: %v", addr, err)
-		}
-
-		if err := ioutil.WriteFile(filename, bz, 0644); err != nil {
-			log.Fatalf("can't write %v to %q: %v", addr, filename, err)
-		}
-
-		log.Printf("wrote %q", filename)
-	}
-}
diff --git a/test/fuzz/p2p/addrbook/testdata/cases/empty b/test/fuzz/p2p/addrbook/testdata/cases/empty
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/test/fuzz/p2p/pex/fuzz_test.go b/test/fuzz/p2p/pex/fuzz_test.go
deleted file mode 100644
index 8a194e730c..0000000000
--- a/test/fuzz/p2p/pex/fuzz_test.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package pex_test
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-	"github.com/tendermint/tendermint/test/fuzz/p2p/pex"
-)
-
-const testdataCasesDir = "testdata/cases"
-
-func TestPexTestdataCases(t *testing.T) {
-	entries, err := os.ReadDir(testdataCasesDir)
-	require.NoError(t, err)
-
-	for _, e := range entries {
-		entry := e
-		t.Run(entry.Name(), func(t *testing.T) {
-			defer func() {
-				r := recover()
-				require.Nilf(t, r, "testdata/cases test panic")
-			}()
-			f, err := os.Open(filepath.Join(testdataCasesDir, entry.Name()))
-			require.NoError(t, err)
-			input, err := ioutil.ReadAll(f)
-			require.NoError(t, err)
-			pex.Fuzz(input)
-		})
-	}
-}
diff --git a/test/fuzz/p2p/pex/init-corpus/main.go b/test/fuzz/p2p/pex/init-corpus/main.go
deleted file mode 100644
index e902168647..0000000000
--- a/test/fuzz/p2p/pex/init-corpus/main.go
+++ /dev/null
@@ -1,84 +0,0 @@
-// nolint: gosec
-package main
-
-import (
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"math/rand"
-	"os"
-	"path/filepath"
-
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/pex"
-	tmp2p "github.com/tendermint/tendermint/proto/tendermint/p2p"
-	"github.com/tendermint/tendermint/types"
-)
-
-func main() {
-	baseDir := flag.String("base", ".", `where the "corpus" directory will live`)
-	flag.Parse()
-
-	initCorpus(*baseDir)
-}
-
-func initCorpus(rootDir string) {
-	log.SetFlags(0)
-
-	corpusDir := filepath.Join(rootDir, "corpus")
-	if err := os.MkdirAll(corpusDir, 0755); err != nil {
-		log.Fatalf("Creating %q err: %v", corpusDir, err)
-	}
-	sizes := []int{0, 1, 2, 17, 5, 31}
-
-	// Make the PRNG predictable
-	rand.Seed(10)
-
-	for _, n := range sizes {
-		var addrs []*p2p.NetAddress
-
-		// IPv4 addresses
-		for i := 0; i < n; i++ {
-			privKey := ed25519.GenPrivKey()
-			addr := fmt.Sprintf(
-				"%s@%v.%v.%v.%v:26656",
-				types.NodeIDFromPubKey(privKey.PubKey()),
-				rand.Int()%256,
-				rand.Int()%256,
-				rand.Int()%256,
-				rand.Int()%256,
-			)
-			netAddr, _ := types.NewNetAddressString(addr)
-			addrs = append(addrs, netAddr)
-		}
-
-		// IPv6 addresses
-		privKey := ed25519.GenPrivKey()
-		ipv6a, err := types.NewNetAddressString(
-			fmt.Sprintf("%s@[ff02::1:114]:26656", types.NodeIDFromPubKey(privKey.PubKey())))
-		if err != nil {
-			log.Fatalf("can't create a new netaddress: %v", err)
-		}
-		addrs = append(addrs, ipv6a)
-
-		msg := tmp2p.PexMessage{
-			Sum: &tmp2p.PexMessage_PexResponse{
-				PexResponse: &tmp2p.PexResponse{Addresses: pex.NetAddressesToProto(addrs)},
-			},
-		}
-		bz, err := msg.Marshal()
-		if err != nil {
-			log.Fatalf("unable to marshal: %v", err)
-		}
-
-		filename := filepath.Join(rootDir, "corpus", fmt.Sprintf("%d", n))
-
-		if err := ioutil.WriteFile(filename, bz, 0644); err != nil {
-			log.Fatalf("can't write %X to %q: %v", bz, filename, err)
-		}
-
-		log.Printf("wrote %q", filename)
-	}
-}
diff --git a/test/fuzz/p2p/pex/reactor_receive.go b/test/fuzz/p2p/pex/reactor_receive.go
deleted file mode 100644
index 388361a4e2..0000000000
--- a/test/fuzz/p2p/pex/reactor_receive.go
+++ /dev/null
@@ -1,95 +0,0 @@
-package pex
-
-import (
-	"net"
-
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/pex"
-	"github.com/tendermint/tendermint/libs/log"
-	"github.com/tendermint/tendermint/libs/service"
-	"github.com/tendermint/tendermint/types"
-	"github.com/tendermint/tendermint/version"
-)
-
-var (
-	pexR   *pex.Reactor
-	peer   p2p.Peer
-	logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
-)
-
-func init() {
-	addrB := pex.NewAddrBook("./testdata/addrbook1", false)
-	pexR = pex.NewReactor(addrB, &pex.ReactorConfig{SeedMode: false})
-	pexR.SetLogger(logger)
-	peer = newFuzzPeer()
-	pexR.AddPeer(peer)
-
-	cfg := config.DefaultP2PConfig()
-	cfg.PexReactor = true
-	sw := p2p.MakeSwitch(cfg, 0, "127.0.0.1", "123.123.123", func(i int, sw *p2p.Switch) *p2p.Switch {
-		return sw
-	}, logger)
-	pexR.SetSwitch(sw)
-}
-
-func Fuzz(data []byte) int {
-	if len(data) == 0 {
-		return -1
-	}
-
-	pexR.Receive(pex.PexChannel, peer, data)
-
-	if !peer.IsRunning() {
-		// do not increase priority for msgs which lead to peer being stopped
-		return 0
-	}
-
-	return 1
-}
-
-type fuzzPeer struct {
-	*service.BaseService
-	m map[string]interface{}
-}
-
-var _ p2p.Peer = (*fuzzPeer)(nil)
-
-func newFuzzPeer() *fuzzPeer {
-	fp := &fuzzPeer{m: make(map[string]interface{})}
-	fp.BaseService = service.NewBaseService(nil, "fuzzPeer", fp)
-	return fp
-}
-
-var privKey = ed25519.GenPrivKey()
-var nodeID = types.NodeIDFromPubKey(privKey.PubKey())
-var defaultNodeInfo = types.NodeInfo{
-	ProtocolVersion: types.ProtocolVersion{
-		P2P:   version.P2PProtocol,
-		Block: version.BlockProtocol,
-		App:   0,
-	},
-	NodeID:     nodeID,
-	ListenAddr: "127.0.0.1:0",
-	Moniker:    "foo1",
-}
-
-func (fp *fuzzPeer) FlushStop()       {}
-func (fp *fuzzPeer) ID() types.NodeID { return nodeID }
-func (fp *fuzzPeer) RemoteIP() net.IP { return net.IPv4(198, 163, 190, 214) }
-func (fp *fuzzPeer) RemoteAddr() net.Addr {
-	return &net.TCPAddr{IP: fp.RemoteIP(), Port: 26656, Zone: ""}
-}
-func (fp *fuzzPeer) IsOutbound() bool             { return false }
-func (fp *fuzzPeer) IsPersistent() bool           { return false }
-func (fp *fuzzPeer) CloseConn() error             { return nil }
-func (fp *fuzzPeer) NodeInfo() types.NodeInfo     { return defaultNodeInfo }
-func (fp *fuzzPeer) Status() p2p.ConnectionStatus { var cs p2p.ConnectionStatus; return cs }
-func (fp *fuzzPeer) SocketAddr() *p2p.NetAddress {
-	return types.NewNetAddress(fp.ID(), fp.RemoteAddr())
-}
-func (fp *fuzzPeer) Send(byte, []byte) bool            { return true }
-func (fp *fuzzPeer) TrySend(byte, []byte) bool         { return true }
-func (fp *fuzzPeer) Set(key string, value interface{}) { fp.m[key] = value }
-func (fp *fuzzPeer) Get(key string) interface{}        { return fp.m[key] }
diff --git a/test/fuzz/p2p/pex/testdata/addrbook1 b/test/fuzz/p2p/pex/testdata/addrbook1
deleted file mode 100644
index acf3e721d9..0000000000
--- a/test/fuzz/p2p/pex/testdata/addrbook1
+++ /dev/null
@@ -1,1705 +0,0 @@
-{
-	"Key": "badd73ebd4eeafbaefc01e0c",
-	"Addrs": [
-		{
-			"Addr": {
-				"IP": "233.174.138.192",
-				"Port": 48186
-			},
-			"Src": {
-				"IP": "198.37.90.115",
-				"Port": 29492
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692278-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				55
-			]
-		},
-		{
-			"Addr": {
-				"IP": "181.28.96.104",
-				"Port": 26776
-			},
-			"Src": {
-				"IP": "183.12.35.241",
-				"Port": 26794
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692289-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				18
-			]
-		},
-		{
-			"Addr": {
-				"IP": "141.85.194.118",
-				"Port": 39768
-			},
-			"Src": {
-				"IP": "120.130.90.63",
-				"Port": 61750
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692383-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				185
-			]
-		},
-		{
-			"Addr": {
-				"IP": "167.72.9.155",
-				"Port": 9542
-			},
-			"Src": {
-				"IP": "95.158.40.108",
-				"Port": 14929
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692604-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				250
-			]
-		},
-		{
-			"Addr": {
-				"IP": "124.118.94.27",
-				"Port": 50333
-			},
-			"Src": {
-				"IP": "208.169.57.96",
-				"Port": 19754
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692046-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				0
-			]
-		},
-		{
-			"Addr": {
-				"IP": "158.197.4.226",
-				"Port": 25979
-			},
-			"Src": {
-				"IP": "3.129.219.107",
-				"Port": 50374
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692211-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				174
-			]
-		},
-		{
-			"Addr": {
-				"IP": "170.42.135.37",
-				"Port": 34524
-			},
-			"Src": {
-				"IP": "73.125.53.212",
-				"Port": 49691
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692241-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				14
-			]
-		},
-		{
-			"Addr": {
-				"IP": "234.69.254.147",
-				"Port": 31885
-			},
-			"Src": {
-				"IP": "167.106.61.34",
-				"Port": 22187
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692609-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				213
-			]
-		},
-		{
-			"Addr": {
-				"IP": "32.176.173.90",
-				"Port": 17250
-			},
-			"Src": {
-				"IP": "118.91.243.12",
-				"Port": 26781
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692273-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				35
-			]
-		},
-		{
-			"Addr": {
-				"IP": "162.154.114.145",
-				"Port": 13875
-			},
-			"Src": {
-				"IP": "198.178.108.166",
-				"Port": 59623
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692373-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				216
-			]
-		},
-		{
-			"Addr": {
-				"IP": "67.128.167.93",
-				"Port": 50513
-			},
-			"Src": {
-				"IP": "104.93.115.28",
-				"Port": 48298
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692399-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				18
-			]
-		},
-		{
-			"Addr": {
-				"IP": "132.175.221.206",
-				"Port": 61037
-			},
-			"Src": {
-				"IP": "112.49.189.65",
-				"Port": 56186
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692422-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				31
-			]
-		},
-		{
-			"Addr": {
-				"IP": "155.49.24.238",
-				"Port": 26261
-			},
-			"Src": {
-				"IP": "97.10.121.246",
-				"Port": 8694
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692473-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				23
-			]
-		},
-		{
-			"Addr": {
-				"IP": "22.215.7.233",
-				"Port": 32487
-			},
-			"Src": {
-				"IP": "214.236.105.23",
-				"Port": 26870
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692572-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				255
-			]
-		},
-		{
-			"Addr": {
-				"IP": "253.170.228.231",
-				"Port": 5002
-			},
-			"Src": {
-				"IP": "225.49.137.209",
-				"Port": 16908
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692619-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				161
-			]
-		},
-		{
-			"Addr": {
-				"IP": "162.126.204.39",
-				"Port": 62618
-			},
-			"Src": {
-				"IP": "250.214.168.131",
-				"Port": 3237
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.69203-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				7
-			]
-		},
-		{
-			"Addr": {
-				"IP": "83.154.228.215",
-				"Port": 23508
-			},
-			"Src": {
-				"IP": "66.33.77.170",
-				"Port": 52207
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692153-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				8
-			]
-		},
-		{
-			"Addr": {
-				"IP": "132.49.63.65",
-				"Port": 53651
-			},
-			"Src": {
-				"IP": "250.164.163.212",
-				"Port": 8612
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692253-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				98
-			]
-		},
-		{
-			"Addr": {
-				"IP": "200.168.34.12",
-				"Port": 61901
-			},
-			"Src": {
-				"IP": "133.185.186.115",
-				"Port": 14186
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692488-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				214
-			]
-		},
-		{
-			"Addr": {
-				"IP": "31.93.45.219",
-				"Port": 61036
-			},
-			"Src": {
-				"IP": "176.191.214.170",
-				"Port": 33402
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692024-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				68
-			]
-		},
-		{
-			"Addr": {
-				"IP": "250.189.27.93",
-				"Port": 51665
-			},
-			"Src": {
-				"IP": "93.161.116.107",
-				"Port": 53482
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692196-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				42
-			]
-		},
-		{
-			"Addr": {
-				"IP": "50.7.17.126",
-				"Port": 64300
-			},
-			"Src": {
-				"IP": "233.234.64.214",
-				"Port": 61061
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692444-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				13
-			]
-		},
-		{
-			"Addr": {
-				"IP": "88.85.81.64",
-				"Port": 34834
-			},
-			"Src": {
-				"IP": "4.240.150.250",
-				"Port": 63064
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692248-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				195
-			]
-		},
-		{
-			"Addr": {
-				"IP": "242.117.244.198",
-				"Port": 4363
-			},
-			"Src": {
-				"IP": "149.29.34.42",
-				"Port": 62567
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692263-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				174
-			]
-		},
-		{
-			"Addr": {
-				"IP": "245.155.175.114",
-				"Port": 37262
-			},
-			"Src": {
-				"IP": "75.85.36.49",
-				"Port": 7101
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692313-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				135
-			]
-		},
-		{
-			"Addr": {
-				"IP": "224.184.241.26",
-				"Port": 55870
-			},
-			"Src": {
-				"IP": "52.15.194.216",
-				"Port": 4733
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692327-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				74
-			]
-		},
-		{
-			"Addr": {
-				"IP": "43.178.26.188",
-				"Port": 55914
-			},
-			"Src": {
-				"IP": "103.250.250.35",
-				"Port": 1566
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692577-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				65
-			]
-		},
-		{
-			"Addr": {
-				"IP": "102.117.172.117",
-				"Port": 35855
-			},
-			"Src": {
-				"IP": "114.152.204.187",
-				"Port": 21156
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692158-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				80
-			]
-		},
-		{
-			"Addr": {
-				"IP": "39.33.41.199",
-				"Port": 51600
-			},
-			"Src": {
-				"IP": "119.65.88.38",
-				"Port": 41239
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692188-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				24
-			]
-		},
-		{
-			"Addr": {
-				"IP": "63.164.56.227",
-				"Port": 1660
-			},
-			"Src": {
-				"IP": "169.54.47.92",
-				"Port": 2818
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692227-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				10
-			]
-		},
-		{
-			"Addr": {
-				"IP": "50.183.223.115",
-				"Port": 26910
-			},
-			"Src": {
-				"IP": "115.98.199.4",
-				"Port": 8767
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692201-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				65
-			]
-		},
-		{
-			"Addr": {
-				"IP": "132.94.203.167",
-				"Port": 53156
-			},
-			"Src": {
-				"IP": "17.195.234.168",
-				"Port": 29405
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692294-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				240
-			]
-		},
-		{
-			"Addr": {
-				"IP": "135.194.230.212",
-				"Port": 14340
-			},
-			"Src": {
-				"IP": "160.2.241.10",
-				"Port": 36553
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692363-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				63
-			]
-		},
-		{
-			"Addr": {
-				"IP": "116.53.200.25",
-				"Port": 27092
-			},
-			"Src": {
-				"IP": "219.104.163.247",
-				"Port": 50476
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692543-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				201
-			]
-		},
-		{
-			"Addr": {
-				"IP": "125.77.44.185",
-				"Port": 55291
-			},
-			"Src": {
-				"IP": "77.15.232.117",
-				"Port": 6934
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692589-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				8
-			]
-		},
-		{
-			"Addr": {
-				"IP": "27.221.35.172",
-				"Port": 26418
-			},
-			"Src": {
-				"IP": "252.18.49.70",
-				"Port": 9835
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692068-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				80
-			]
-		},
-		{
-			"Addr": {
-				"IP": "133.225.167.135",
-				"Port": 59468
-			},
-			"Src": {
-				"IP": "110.223.163.74",
-				"Port": 22576
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.69213-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				164
-			]
-		},
-		{
-			"Addr": {
-				"IP": "155.131.178.240",
-				"Port": 60476
-			},
-			"Src": {
-				"IP": "143.82.157.1",
-				"Port": 43821
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692173-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				34
-			]
-		},
-		{
-			"Addr": {
-				"IP": "207.13.48.52",
-				"Port": 28549
-			},
-			"Src": {
-				"IP": "238.224.177.29",
-				"Port": 44100
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692594-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				113
-			]
-		},
-		{
-			"Addr": {
-				"IP": "91.137.2.184",
-				"Port": 44887
-			},
-			"Src": {
-				"IP": "72.131.70.84",
-				"Port": 29960
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692627-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				199
-			]
-		},
-		{
-			"Addr": {
-				"IP": "169.59.252.76",
-				"Port": 57711
-			},
-			"Src": {
-				"IP": "194.132.91.119",
-				"Port": 18037
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692478-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				124
-			]
-		},
-		{
-			"Addr": {
-				"IP": "25.174.143.229",
-				"Port": 41540
-			},
-			"Src": {
-				"IP": "58.215.132.148",
-				"Port": 64950
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692534-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				88
-			]
-		},
-		{
-			"Addr": {
-				"IP": "71.239.78.239",
-				"Port": 46938
-			},
-			"Src": {
-				"IP": "156.98.186.169",
-				"Port": 32046
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692116-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				154
-			]
-		},
-		{
-			"Addr": {
-				"IP": "94.137.107.61",
-				"Port": 20756
-			},
-			"Src": {
-				"IP": "101.201.138.179",
-				"Port": 22877
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692414-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				233
-			]
-		},
-		{
-			"Addr": {
-				"IP": "216.62.174.112",
-				"Port": 60162
-			},
-			"Src": {
-				"IP": "225.114.119.144",
-				"Port": 1575
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692464-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				132
-			]
-		},
-		{
-			"Addr": {
-				"IP": "65.183.81.125",
-				"Port": 17511
-			},
-			"Src": {
-				"IP": "12.96.14.61",
-				"Port": 42308
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692308-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				153
-			]
-		},
-		{
-			"Addr": {
-				"IP": "142.26.87.52",
-				"Port": 41967
-			},
-			"Src": {
-				"IP": "60.124.157.139",
-				"Port": 20727
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692321-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				29
-			]
-		},
-		{
-			"Addr": {
-				"IP": "13.77.198.44",
-				"Port": 54508
-			},
-			"Src": {
-				"IP": "142.73.70.174",
-				"Port": 19525
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692553-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				170
-			]
-		},
-		{
-			"Addr": {
-				"IP": "63.192.219.12",
-				"Port": 46603
-			},
-			"Src": {
-				"IP": "26.136.66.29",
-				"Port": 38924
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692558-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				203
-			]
-		},
-		{
-			"Addr": {
-				"IP": "120.82.251.151",
-				"Port": 43723
-			},
-			"Src": {
-				"IP": "136.104.122.219",
-				"Port": 47452
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692599-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				103
-			]
-		},
-		{
-			"Addr": {
-				"IP": "74.79.96.159",
-				"Port": 46646
-			},
-			"Src": {
-				"IP": "218.60.242.116",
-				"Port": 5361
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692145-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				121
-			]
-		},
-		{
-			"Addr": {
-				"IP": "194.65.211.174",
-				"Port": 43464
-			},
-			"Src": {
-				"IP": "87.5.112.153",
-				"Port": 56348
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692163-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				96
-			]
-		},
-		{
-			"Addr": {
-				"IP": "237.158.179.80",
-				"Port": 32231
-			},
-			"Src": {
-				"IP": "210.240.52.244",
-				"Port": 29142
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692183-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				27
-			]
-		},
-		{
-			"Addr": {
-				"IP": "81.157.122.4",
-				"Port": 9917
-			},
-			"Src": {
-				"IP": "213.226.144.152",
-				"Port": 29950
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692614-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				33
-			]
-		},
-		{
-			"Addr": {
-				"IP": "180.147.73.220",
-				"Port": 367
-			},
-			"Src": {
-				"IP": "32.229.253.215",
-				"Port": 62165
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692529-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				240
-			]
-		},
-		{
-			"Addr": {
-				"IP": "83.110.235.17",
-				"Port": 33231
-			},
-			"Src": {
-				"IP": "230.54.162.85",
-				"Port": 51569
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692563-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				234
-			]
-		},
-		{
-			"Addr": {
-				"IP": "100.252.20.2",
-				"Port": 1633
-			},
-			"Src": {
-				"IP": "52.136.47.198",
-				"Port": 31916
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692644-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				254
-			]
-		},
-		{
-			"Addr": {
-				"IP": "74.5.247.79",
-				"Port": 18703
-			},
-			"Src": {
-				"IP": "200.247.68.128",
-				"Port": 55844
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692378-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				160
-			]
-		},
-		{
-			"Addr": {
-				"IP": "17.220.231.87",
-				"Port": 59015
-			},
-			"Src": {
-				"IP": "54.207.49.4",
-				"Port": 17877
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692404-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				21
-			]
-		},
-		{
-			"Addr": {
-				"IP": "156.194.57.127",
-				"Port": 18944
-			},
-			"Src": {
-				"IP": "154.94.235.84",
-				"Port": 61610
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692439-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				32
-			]
-		},
-		{
-			"Addr": {
-				"IP": "137.57.172.158",
-				"Port": 32031
-			},
-			"Src": {
-				"IP": "144.160.225.126",
-				"Port": 43225
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692568-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				4
-			]
-		},
-		{
-			"Addr": {
-				"IP": "101.220.101.200",
-				"Port": 26480
-			},
-			"Src": {
-				"IP": "130.225.42.1",
-				"Port": 2522
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692637-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				173
-			]
-		},
-		{
-			"Addr": {
-				"IP": "136.233.185.164",
-				"Port": 34011
-			},
-			"Src": {
-				"IP": "112.127.216.43",
-				"Port": 55317
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692649-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				106
-			]
-		},
-		{
-			"Addr": {
-				"IP": "101.189.107.148",
-				"Port": 28671
-			},
-			"Src": {
-				"IP": "213.55.140.235",
-				"Port": 2547
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692178-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				72
-			]
-		},
-		{
-			"Addr": {
-				"IP": "61.190.60.64",
-				"Port": 58467
-			},
-			"Src": {
-				"IP": "206.86.120.31",
-				"Port": 54422
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692358-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				191
-			]
-		},
-		{
-			"Addr": {
-				"IP": "227.51.127.223",
-				"Port": 52754
-			},
-			"Src": {
-				"IP": "124.24.12.47",
-				"Port": 59878
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692393-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				122
-			]
-		},
-		{
-			"Addr": {
-				"IP": "101.19.152.238",
-				"Port": 47491
-			},
-			"Src": {
-				"IP": "211.30.216.184",
-				"Port": 17610
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692135-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				251
-			]
-		},
-		{
-			"Addr": {
-				"IP": "182.198.35.238",
-				"Port": 15065
-			},
-			"Src": {
-				"IP": "239.67.104.149",
-				"Port": 43039
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692268-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				179
-			]
-		},
-		{
-			"Addr": {
-				"IP": "233.12.68.51",
-				"Port": 47544
-			},
-			"Src": {
-				"IP": "203.224.119.48",
-				"Port": 23337
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692454-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				51
-			]
-		},
-		{
-			"Addr": {
-				"IP": "181.30.35.80",
-				"Port": 500
-			},
-			"Src": {
-				"IP": "174.200.32.161",
-				"Port": 10174
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692503-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				69
-			]
-		},
-		{
-			"Addr": {
-				"IP": "49.104.89.21",
-				"Port": 54774
-			},
-			"Src": {
-				"IP": "245.95.238.161",
-				"Port": 14339
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692654-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				120
-			]
-		},
-		{
-			"Addr": {
-				"IP": "65.150.169.199",
-				"Port": 11589
-			},
-			"Src": {
-				"IP": "150.110.183.207",
-				"Port": 17694
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692041-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				182
-			]
-		},
-		{
-			"Addr": {
-				"IP": "84.203.198.48",
-				"Port": 47122
-			},
-			"Src": {
-				"IP": "141.209.147.221",
-				"Port": 26085
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692056-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				74
-			]
-		},
-		{
-			"Addr": {
-				"IP": "220.10.106.180",
-				"Port": 27439
-			},
-			"Src": {
-				"IP": "124.170.244.46",
-				"Port": 5249
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692125-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				166
-			]
-		},
-		{
-			"Addr": {
-				"IP": "120.208.32.34",
-				"Port": 27224
-			},
-			"Src": {
-				"IP": "64.194.118.103",
-				"Port": 24388
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.69251-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				149
-			]
-		},
-		{
-			"Addr": {
-				"IP": "245.182.67.231",
-				"Port": 58067
-			},
-			"Src": {
-				"IP": "62.108.238.220",
-				"Port": 41851
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692522-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				201
-			]
-		},
-		{
-			"Addr": {
-				"IP": "50.81.160.105",
-				"Port": 8113
-			},
-			"Src": {
-				"IP": "129.187.68.121",
-				"Port": 58612
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692284-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				94
-			]
-		},
-		{
-			"Addr": {
-				"IP": "101.116.47.155",
-				"Port": 20287
-			},
-			"Src": {
-				"IP": "94.34.167.170",
-				"Port": 41821
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692299-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				134
-			]
-		},
-		{
-			"Addr": {
-				"IP": "159.253.213.86",
-				"Port": 5222
-			},
-			"Src": {
-				"IP": "124.47.162.125",
-				"Port": 45742
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692429-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				25
-			]
-		},
-		{
-			"Addr": {
-				"IP": "124.72.81.213",
-				"Port": 35723
-			},
-			"Src": {
-				"IP": "201.65.186.55",
-				"Port": 26602
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692493-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				199
-			]
-		},
-		{
-			"Addr": {
-				"IP": "77.216.197.130",
-				"Port": 49129
-			},
-			"Src": {
-				"IP": "245.160.14.27",
-				"Port": 38908
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692517-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				58
-			]
-		},
-		{
-			"Addr": {
-				"IP": "175.46.154.0",
-				"Port": 15297
-			},
-			"Src": {
-				"IP": "6.10.7.13",
-				"Port": 9657
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692583-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				89
-			]
-		},
-		{
-			"Addr": {
-				"IP": "176.71.131.235",
-				"Port": 14342
-			},
-			"Src": {
-				"IP": "1.36.215.198",
-				"Port": 21709
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692206-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				135
-			]
-		},
-		{
-			"Addr": {
-				"IP": "34.211.134.186",
-				"Port": 31608
-			},
-			"Src": {
-				"IP": "187.87.12.183",
-				"Port": 32977
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692221-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				71
-			]
-		},
-		{
-			"Addr": {
-				"IP": "238.63.227.107",
-				"Port": 49502
-			},
-			"Src": {
-				"IP": "185.51.127.143",
-				"Port": 22728
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692483-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				61
-			]
-		},
-		{
-			"Addr": {
-				"IP": "160.65.76.45",
-				"Port": 27307
-			},
-			"Src": {
-				"IP": "170.175.198.16",
-				"Port": 44759
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692051-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				36
-			]
-		},
-		{
-			"Addr": {
-				"IP": "152.22.79.90",
-				"Port": 25861
-			},
-			"Src": {
-				"IP": "216.183.31.190",
-				"Port": 9185
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692409-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				163
-			]
-		},
-		{
-			"Addr": {
-				"IP": "200.2.175.37",
-				"Port": 57270
-			},
-			"Src": {
-				"IP": "108.20.254.94",
-				"Port": 32812
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692434-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				96
-			]
-		},
-		{
-			"Addr": {
-				"IP": "111.16.237.10",
-				"Port": 45200
-			},
-			"Src": {
-				"IP": "215.82.246.115",
-				"Port": 42333
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692469-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				21
-			]
-		},
-		{
-			"Addr": {
-				"IP": "166.217.195.221",
-				"Port": 4579
-			},
-			"Src": {
-				"IP": "148.153.131.183",
-				"Port": 13848
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692498-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				78
-			]
-		},
-		{
-			"Addr": {
-				"IP": "1.226.156.147",
-				"Port": 61660
-			},
-			"Src": {
-				"IP": "169.138.16.69",
-				"Port": 23455
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692548-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				121
-			]
-		},
-		{
-			"Addr": {
-				"IP": "108.209.27.58",
-				"Port": 59102
-			},
-			"Src": {
-				"IP": "140.27.139.90",
-				"Port": 52154
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692014-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				53
-			]
-		},
-		{
-			"Addr": {
-				"IP": "221.244.202.95",
-				"Port": 5032
-			},
-			"Src": {
-				"IP": "230.152.141.80",
-				"Port": 19457
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692168-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				106
-			]
-		},
-		{
-			"Addr": {
-				"IP": "55.87.1.138",
-				"Port": 39686
-			},
-			"Src": {
-				"IP": "55.22.167.132",
-				"Port": 35663
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692258-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				174
-			]
-		},
-		{
-			"Addr": {
-				"IP": "209.53.148.74",
-				"Port": 18502
-			},
-			"Src": {
-				"IP": "195.108.121.25",
-				"Port": 16730
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692304-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				180
-			]
-		},
-		{
-			"Addr": {
-				"IP": "21.66.206.236",
-				"Port": 10771
-			},
-			"Src": {
-				"IP": "236.195.50.16",
-				"Port": 30697
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692368-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				22
-			]
-		},
-		{
-			"Addr": {
-				"IP": "190.87.236.91",
-				"Port": 58378
-			},
-			"Src": {
-				"IP": "72.224.218.34",
-				"Port": 44817
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692459-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				127
-			]
-		},
-		{
-			"Addr": {
-				"IP": "197.172.79.170",
-				"Port": 24958
-			},
-			"Src": {
-				"IP": "71.22.4.12",
-				"Port": 28558
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692036-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				251
-			]
-		},
-		{
-			"Addr": {
-				"IP": "160.176.234.94",
-				"Port": 47013
-			},
-			"Src": {
-				"IP": "212.172.24.59",
-				"Port": 29594
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692062-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				99
-			]
-		},
-		{
-			"Addr": {
-				"IP": "170.206.180.18",
-				"Port": 26212
-			},
-			"Src": {
-				"IP": "228.135.62.18",
-				"Port": 26164
-			},
-			"Attempts": 0,
-			"LastAttempt": "2017-11-07T01:11:34.692234-07:00",
-			"LastSuccess": "0001-01-01T00:00:00Z",
-			"BucketType": 1,
-			"Buckets": [
-				34
-			]
-		}
-	]
-}
diff --git a/test/fuzz/p2p/pex/testdata/cases/empty b/test/fuzz/p2p/pex/testdata/cases/empty
deleted file mode 100644
index e69de29bb2..0000000000

From 5703ae2fb3dc1aede7af118f8becfbb1ad392368 Mon Sep 17 00:00:00 2001
From: Callum Waters <cmwaters19@gmail.com>
Date: Tue, 5 Oct 2021 20:19:12 +0200
Subject: [PATCH 19/57] e2e: automatically prune old app snapshots (#7034)

This PR tackles the case of using the e2e application in a long lived testnet. The application continually saves snapshots (usually every 100 blocks) which after a while bloats the size of the application. This PR prunes older snapshots so that only the most recent 10 snapshots remain.
---
 test/e2e/app/app.go            |  4 ++++
 test/e2e/app/snapshots.go      | 24 ++++++++++++++++++++++++
 test/e2e/generator/generate.go |  2 +-
 3 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/test/e2e/app/app.go b/test/e2e/app/app.go
index 0a0194c980..e7ba110e9e 100644
--- a/test/e2e/app/app.go
+++ b/test/e2e/app/app.go
@@ -184,6 +184,10 @@ func (app *Application) Commit() abci.ResponseCommit {
 			panic(err)
 		}
 		app.logger.Info("Created state sync snapshot", "height", snapshot.Height)
+		err = app.snapshots.Prune(maxSnapshotCount)
+		if err != nil {
+			app.logger.Error("Failed to prune snapshots", "err", err)
+		}
 	}
 	retainHeight := int64(0)
 	if app.cfg.RetainBlocks > 0 {
diff --git a/test/e2e/app/snapshots.go b/test/e2e/app/snapshots.go
index 4ef20375ff..6a9c0e0dcf 100644
--- a/test/e2e/app/snapshots.go
+++ b/test/e2e/app/snapshots.go
@@ -16,6 +16,9 @@ import (
 
 const (
 	snapshotChunkSize = 1e6
+
+	// Keep only the most recent 10 snapshots. Older snapshots are pruned
+	maxSnapshotCount = 10
 )
 
 // SnapshotStore stores state sync snapshots. Snapshots are stored simply as
@@ -105,6 +108,27 @@ func (s *SnapshotStore) Create(state *State) (abci.Snapshot, error) {
 	return snapshot, nil
 }
 
+// Prune removes old snapshots ensuring only the most recent n snapshots remain
+func (s *SnapshotStore) Prune(n int) error {
+	s.Lock()
+	defer s.Unlock()
+	// snapshots are appended to the metadata struct, hence pruning removes from
+	// the front of the array
+	i := 0
+	for ; i < len(s.metadata)-n; i++ {
+		h := s.metadata[i].Height
+		if err := os.Remove(filepath.Join(s.dir, fmt.Sprintf("%v.json", h))); err != nil {
+			return err
+		}
+	}
+
+	// update metadata by removing the deleted snapshots
+	pruned := make([]abci.Snapshot, len(s.metadata[i:]))
+	copy(pruned, s.metadata[i:])
+	s.metadata = pruned
+	return nil
+}
+
 // List lists available snapshots.
 func (s *SnapshotStore) List() ([]*abci.Snapshot, error) {
 	s.RLock()
diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index 5c47faa23d..0a2d39665f 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -53,7 +53,7 @@ var (
 		e2e.StateSyncRPC:      45,
 	}
 	nodePersistIntervals  = uniformChoice{0, 1, 5}
-	nodeSnapshotIntervals = uniformChoice{0, 3}
+	nodeSnapshotIntervals = uniformChoice{0, 5}
 	nodeRetainBlocks      = uniformChoice{0, 2 * int(e2e.EvidenceAgeHeight), 4 * int(e2e.EvidenceAgeHeight)}
 	nodePerturbations     = probSetChoice{
 		"disconnect": 0.1,

From 3ea81bfaa7c04a5a993bca1d97e1b1f4d8be8e4a Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 5 Oct 2021 16:09:31 -0400
Subject: [PATCH 20/57] p2p: remove wdrr queue (#7064)

This code hasn't been battle tested, and seems to have grown
increasingly flaky int tests. Given our general direction of reducing
queue complexity over the next couple of releases I think it makes
sense to remove it.
---
 CHANGELOG_PENDING.md             |   1 +
 config/config.go                 |   2 +-
 internal/p2p/pqueue_test.go      |   3 +
 internal/p2p/router.go           |  20 +--
 internal/p2p/router_init_test.go |   8 -
 internal/p2p/wdrr_queue.go       | 287 -------------------------------
 internal/p2p/wdrr_queue_test.go  | 208 ----------------------
 test/e2e/generator/generate.go   |   2 +-
 test/e2e/pkg/testnet.go          |   2 +-
 9 files changed, 11 insertions(+), 522 deletions(-)
 delete mode 100644 internal/p2p/wdrr_queue.go
 delete mode 100644 internal/p2p/wdrr_queue_test.go

diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md
index 0a4c90f400..c44c58ef06 100644
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -24,6 +24,7 @@ Special thanks to external contributors on this release:
   - [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)
 
 - Blockchain Protocol
 
diff --git a/config/config.go b/config/config.go
index a393e6edc5..349e5a6f77 100644
--- a/config/config.go
+++ b/config/config.go
@@ -710,7 +710,7 @@ type P2PConfig struct { //nolint: maligned
 	TestDialFail bool `mapstructure:"test-dial-fail"`
 
 	// Makes it possible to configure which queue backend the p2p
-	// layer uses. Options are: "fifo", "priority" and "wdrr",
+	// layer uses. Options are: "fifo" and "priority",
 	// with the default being "priority".
 	QueueType string `mapstructure:"queue-type"`
 }
diff --git a/internal/p2p/pqueue_test.go b/internal/p2p/pqueue_test.go
index ddb7addbe6..c038408ef7 100644
--- a/internal/p2p/pqueue_test.go
+++ b/internal/p2p/pqueue_test.go
@@ -4,9 +4,12 @@ import (
 	"testing"
 	"time"
 
+	gogotypes "github.com/gogo/protobuf/types"
 	"github.com/tendermint/tendermint/libs/log"
 )
 
+type testMessage = gogotypes.StringValue
+
 func TestCloseWhileDequeueFull(t *testing.T) {
 	enqueueLength := 5
 	chDescs := []ChannelDescriptor{
diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index d68f16c4f9..ef1eef5644 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -133,8 +133,8 @@ type RouterOptions struct {
 	// no timeout.
 	HandshakeTimeout time.Duration
 
-	// QueueType must be "wdrr" (Weighed Deficit Round Robin), "priority", or
-	// "fifo". Defaults to "fifo".
+	// QueueType must be, "priority", or "fifo". Defaults to
+	// "fifo".
 	QueueType string
 
 	// MaxIncomingConnectionAttempts rate limits the number of incoming connection
@@ -176,7 +176,6 @@ type RouterOptions struct {
 const (
 	queueTypeFifo     = "fifo"
 	queueTypePriority = "priority"
-	queueTypeWDRR     = "wdrr"
 )
 
 // Validate validates router options.
@@ -184,8 +183,8 @@ func (o *RouterOptions) Validate() error {
 	switch o.QueueType {
 	case "":
 		o.QueueType = queueTypeFifo
-	case queueTypeFifo, queueTypeWDRR, queueTypePriority:
-		// passI me
+	case queueTypeFifo, queueTypePriority:
+		// pass
 	default:
 		return fmt.Errorf("queue type %q is not supported", o.QueueType)
 	}
@@ -347,17 +346,6 @@ func (r *Router) createQueueFactory() (func(int) queue, error) {
 			return q
 		}, nil
 
-	case queueTypeWDRR:
-		return func(size int) queue {
-			if size%2 != 0 {
-				size++
-			}
-
-			q := newWDRRScheduler(r.logger, r.metrics, r.chDescs, uint(size)/2, uint(size)/2, defaultCapacity)
-			q.start()
-			return q
-		}, nil
-
 	default:
 		return nil, fmt.Errorf("cannot construct queue of type %q", r.options.QueueType)
 	}
diff --git a/internal/p2p/router_init_test.go b/internal/p2p/router_init_test.go
index 3622c0cc12..b90d2a3dd9 100644
--- a/internal/p2p/router_init_test.go
+++ b/internal/p2p/router_init_test.go
@@ -38,14 +38,6 @@ func TestRouter_ConstructQueueFactory(t *testing.T) {
 		require.True(t, ok)
 		defer q.close()
 	})
-	t.Run("WDRR", func(t *testing.T) {
-		opts := RouterOptions{QueueType: queueTypeWDRR}
-		r, err := NewRouter(log.NewNopLogger(), nil, types.NodeInfo{}, nil, nil, nil, opts)
-		require.NoError(t, err)
-		q, ok := r.queueFactory(1).(*wdrrScheduler)
-		require.True(t, ok)
-		defer q.close()
-	})
 	t.Run("NonExistant", func(t *testing.T) {
 		opts := RouterOptions{QueueType: "fast"}
 		_, err := NewRouter(log.NewNopLogger(), nil, types.NodeInfo{}, nil, nil, nil, opts)
diff --git a/internal/p2p/wdrr_queue.go b/internal/p2p/wdrr_queue.go
deleted file mode 100644
index 1b75ffce88..0000000000
--- a/internal/p2p/wdrr_queue.go
+++ /dev/null
@@ -1,287 +0,0 @@
-package p2p
-
-import (
-	"fmt"
-	"sort"
-	"strconv"
-
-	"github.com/gogo/protobuf/proto"
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/libs/log"
-)
-
-// wrappedEnvelope wraps a p2p Envelope with its precomputed size.
-type wrappedEnvelope struct {
-	envelope Envelope
-	size     uint
-}
-
-// assert the WDRR scheduler implements the queue interface at compile-time
-var _ queue = (*wdrrScheduler)(nil)
-
-// wdrrQueue implements a Weighted Deficit Round Robin (WDRR) scheduling
-// algorithm via the queue interface. A WDRR queue is created per peer, where
-// the queue will have N number of flows. Each flow corresponds to a p2p Channel,
-// so there are n input flows and a single output source, the peer's connection.
-//
-// The WDRR scheduler contains a shared buffer with a fixed capacity.
-//
-// Each flow has the following:
-// - quantum: The number of bytes that is added to the deficit counter of the
-//   flow in each round. The flow can send at most quantum bytes at a time. Each
-//   flow has its own unique quantum, which gives the queue its weighted nature.
-//   A higher quantum corresponds to a higher weight/priority. The quantum is
-//   computed as MaxSendBytes * Priority.
-// - deficit counter: The number of bytes that the flow is allowed to transmit
-//   when it is its turn.
-//
-// See: https://en.wikipedia.org/wiki/Deficit_round_robin
-type wdrrScheduler struct {
-	logger       log.Logger
-	metrics      *Metrics
-	chDescs      []ChannelDescriptor
-	capacity     uint
-	size         uint
-	chPriorities map[ChannelID]uint
-	buffer       map[ChannelID][]wrappedEnvelope
-	quanta       map[ChannelID]uint
-	deficits     map[ChannelID]uint
-
-	closer *tmsync.Closer
-	doneCh *tmsync.Closer
-
-	enqueueCh chan Envelope
-	dequeueCh chan Envelope
-}
-
-func newWDRRScheduler(
-	logger log.Logger,
-	m *Metrics,
-	chDescs []ChannelDescriptor,
-	enqueueBuf, dequeueBuf, capacity uint,
-) *wdrrScheduler {
-
-	// copy each ChannelDescriptor and sort them by channel priority
-	chDescsCopy := make([]ChannelDescriptor, len(chDescs))
-	copy(chDescsCopy, chDescs)
-	sort.Slice(chDescsCopy, func(i, j int) bool { return chDescsCopy[i].Priority > chDescsCopy[j].Priority })
-
-	var (
-		buffer       = make(map[ChannelID][]wrappedEnvelope)
-		chPriorities = make(map[ChannelID]uint)
-		quanta       = make(map[ChannelID]uint)
-		deficits     = make(map[ChannelID]uint)
-	)
-
-	for _, chDesc := range chDescsCopy {
-		chID := ChannelID(chDesc.ID)
-		chPriorities[chID] = uint(chDesc.Priority)
-		buffer[chID] = make([]wrappedEnvelope, 0)
-		quanta[chID] = chDesc.MaxSendBytes * uint(chDesc.Priority)
-	}
-
-	return &wdrrScheduler{
-		logger:       logger.With("queue", "wdrr"),
-		metrics:      m,
-		capacity:     capacity,
-		chPriorities: chPriorities,
-		chDescs:      chDescsCopy,
-		buffer:       buffer,
-		quanta:       quanta,
-		deficits:     deficits,
-		closer:       tmsync.NewCloser(),
-		doneCh:       tmsync.NewCloser(),
-		enqueueCh:    make(chan Envelope, enqueueBuf),
-		dequeueCh:    make(chan Envelope, dequeueBuf),
-	}
-}
-
-// enqueue returns an unbuffered write-only channel which a producer can send on.
-func (s *wdrrScheduler) enqueue() chan<- Envelope {
-	return s.enqueueCh
-}
-
-// dequeue returns an unbuffered read-only channel which a consumer can read from.
-func (s *wdrrScheduler) dequeue() <-chan Envelope {
-	return s.dequeueCh
-}
-
-func (s *wdrrScheduler) closed() <-chan struct{} {
-	return s.closer.Done()
-}
-
-// close closes the WDRR queue. After this call enqueue() will block, so the
-// caller must select on closed() as well to avoid blocking forever. The
-// enqueue() and dequeue() along with the internal channels will NOT be closed.
-// Note, close() will block until all externally spawned goroutines have exited.
-func (s *wdrrScheduler) close() {
-	s.closer.Close()
-	<-s.doneCh.Done()
-}
-
-// start starts the WDRR queue process in a blocking goroutine. This must be
-// called before the queue can start to process and accept Envelopes.
-func (s *wdrrScheduler) start() {
-	go s.process()
-}
-
-// process starts a blocking WDRR scheduler process, where we continuously
-// evaluate if we need to attempt to enqueue an Envelope or schedule Envelopes
-// to be dequeued and subsequently read and sent on the source connection.
-// Internally, each p2p Channel maps to a flow, where each flow has a deficit
-// and a quantum.
-//
-// For each Envelope requested to be enqueued, we evaluate if there is sufficient
-// capacity in the shared buffer to add the Envelope. If so, it is added.
-// Otherwise, we evaluate all flows of lower priority where we attempt find an
-// existing Envelope in the shared buffer of sufficient size that can be dropped
-// in place of the incoming Envelope. If there is no such Envelope that can be
-// dropped, then the incoming Envelope is dropped.
-//
-// When there is nothing to be enqueued, we perform the WDRR algorithm and
-// determine which Envelopes can be dequeued. For each Envelope that can be
-// dequeued, it is sent on the dequeueCh. Specifically, for each flow, if it is
-// non-empty, its deficit counter is incremented by its quantum value. Then, the
-// value of the deficit counter is a maximal amount of bytes that can be sent at
-// this round. If the deficit counter is greater than the Envelopes's message
-// size at the head of the queue (HoQ), this envelope can be sent and the value
-// of the counter is decremented by the message's size. Then, the size of the
-// next Envelopes's message is compared to the counter value, etc. Once the flow
-// is empty or the value of the counter is insufficient, the scheduler will skip
-// to the next flow. If the flow is empty, the value of the deficit counter is
-// reset to 0.
-//
-// XXX/TODO: Evaluate the single goroutine scheduler mechanism. In other words,
-// evaluate the effectiveness and performance of having a single goroutine
-// perform handling both enqueueing and dequeueing logic. Specifically, there
-// is potentially contention between reading off of enqueueCh and trying to
-// enqueue while also attempting to perform the WDRR algorithm and find the next
-// set of Envelope(s) to send on the dequeueCh. Alternatively, we could consider
-// separate scheduling goroutines, but then that requires the use of mutexes and
-// possibly a degrading performance.
-func (s *wdrrScheduler) process() {
-	defer s.doneCh.Close()
-
-	for {
-		select {
-		case <-s.closer.Done():
-			return
-
-		case e := <-s.enqueueCh:
-			// attempt to enqueue the incoming Envelope
-			chIDStr := strconv.Itoa(int(e.channelID))
-			wEnv := wrappedEnvelope{envelope: e, size: uint(proto.Size(e.Message))}
-			msgSize := wEnv.size
-
-			s.metrics.PeerPendingSendBytes.With("peer_id", string(e.To)).Add(float64(msgSize))
-
-			// If we're at capacity, we need to either drop the incoming Envelope or
-			// an Envelope from a lower priority flow. Otherwise, we add the (wrapped)
-			// envelope to the flow's queue.
-			if s.size+wEnv.size > s.capacity {
-				chPriority := s.chPriorities[e.channelID]
-
-				var (
-					canDrop  bool
-					dropIdx  int
-					dropChID ChannelID
-				)
-
-				// Evaluate all lower priority flows and determine if there exists an
-				// Envelope that is of equal or greater size that we can drop in favor
-				// of the incoming Envelope.
-				for i := len(s.chDescs) - 1; i >= 0 && uint(s.chDescs[i].Priority) < chPriority && !canDrop; i-- {
-					currChID := ChannelID(s.chDescs[i].ID)
-					flow := s.buffer[currChID]
-
-					for j := 0; j < len(flow) && !canDrop; j++ {
-						if flow[j].size >= wEnv.size {
-							canDrop = true
-							dropIdx = j
-							dropChID = currChID
-							break
-						}
-					}
-				}
-
-				// If we can drop an existing Envelope, drop it and enqueue the incoming
-				// Envelope.
-				if canDrop {
-					chIDStr = strconv.Itoa(int(dropChID))
-					chPriority = s.chPriorities[dropChID]
-					msgSize = s.buffer[dropChID][dropIdx].size
-
-					// Drop Envelope for the lower priority flow and update the queue's
-					// buffer size
-					s.size -= msgSize
-					s.buffer[dropChID] = append(s.buffer[dropChID][:dropIdx], s.buffer[dropChID][dropIdx+1:]...)
-
-					// add the incoming Envelope and update queue's buffer size
-					s.size += wEnv.size
-					s.buffer[e.channelID] = append(s.buffer[e.channelID], wEnv)
-					s.metrics.PeerQueueMsgSize.With("ch_id", chIDStr).Set(float64(wEnv.size))
-				}
-
-				// We either dropped the incoming Enevelope or one from an existing
-				// lower priority flow.
-				s.metrics.PeerQueueDroppedMsgs.With("ch_id", chIDStr).Add(1)
-				s.logger.Debug(
-					"dropped envelope",
-					"ch_id", chIDStr,
-					"priority", chPriority,
-					"capacity", s.capacity,
-					"msg_size", msgSize,
-				)
-			} else {
-				// we have sufficient capacity to enqueue the incoming Envelope
-				s.metrics.PeerQueueMsgSize.With("ch_id", chIDStr).Set(float64(wEnv.size))
-				s.buffer[e.channelID] = append(s.buffer[e.channelID], wEnv)
-				s.size += wEnv.size
-			}
-
-		default:
-			// perform the WDRR algorithm
-			for _, chDesc := range s.chDescs {
-				chID := ChannelID(chDesc.ID)
-
-				// only consider non-empty flows
-				if len(s.buffer[chID]) > 0 {
-					// bump flow's quantum
-					s.deficits[chID] += s.quanta[chID]
-
-					// grab the flow's current deficit counter and HoQ (wrapped) Envelope
-					d := s.deficits[chID]
-					we := s.buffer[chID][0]
-
-					// While the flow is non-empty and we can send the current Envelope
-					// on the dequeueCh:
-					//
-					// 1. send the Envelope
-					// 2. update the scheduler's shared buffer's size
-					// 3. update the flow's deficit
-					// 4. remove from the flow's queue
-					// 5. grab the next HoQ Envelope and flow's deficit
-					for len(s.buffer[chID]) > 0 && d >= we.size {
-						s.metrics.PeerSendBytesTotal.With(
-							"chID", fmt.Sprint(chID),
-							"peer_id", string(we.envelope.To)).Add(float64(we.size))
-						s.dequeueCh <- we.envelope
-						s.size -= we.size
-						s.deficits[chID] -= we.size
-						s.buffer[chID] = s.buffer[chID][1:]
-
-						if len(s.buffer[chID]) > 0 {
-							d = s.deficits[chID]
-							we = s.buffer[chID][0]
-						}
-					}
-				}
-
-				// reset the flow's deficit to zero if it is empty
-				if len(s.buffer[chID]) == 0 {
-					s.deficits[chID] = 0
-				}
-			}
-		}
-	}
-}
diff --git a/internal/p2p/wdrr_queue_test.go b/internal/p2p/wdrr_queue_test.go
deleted file mode 100644
index d49c77e765..0000000000
--- a/internal/p2p/wdrr_queue_test.go
+++ /dev/null
@@ -1,208 +0,0 @@
-package p2p
-
-import (
-	"math"
-	"math/rand"
-	"testing"
-	"time"
-
-	gogotypes "github.com/gogo/protobuf/types"
-	"github.com/stretchr/testify/require"
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/libs/log"
-)
-
-type testMessage = gogotypes.StringValue
-
-func TestWDRRQueue_EqualWeights(t *testing.T) {
-	chDescs := []ChannelDescriptor{
-		{ID: 0x01, Priority: 1, MaxSendBytes: 4},
-		{ID: 0x02, Priority: 1, MaxSendBytes: 4},
-		{ID: 0x03, Priority: 1, MaxSendBytes: 4},
-		{ID: 0x04, Priority: 1, MaxSendBytes: 4},
-		{ID: 0x05, Priority: 1, MaxSendBytes: 4},
-		{ID: 0x06, Priority: 1, MaxSendBytes: 4},
-	}
-
-	peerQueue := newWDRRScheduler(log.NewNopLogger(), NopMetrics(), chDescs, 1000, 1000, 120)
-	peerQueue.start()
-
-	totalMsgs := make(map[ChannelID]int)
-	deliveredMsgs := make(map[ChannelID]int)
-	successRates := make(map[ChannelID]float64)
-
-	closer := tmsync.NewCloser()
-
-	go func() {
-		timout := 10 * time.Second
-		ticker := time.NewTicker(timout)
-		defer ticker.Stop()
-
-		for {
-			select {
-			case e := <-peerQueue.dequeue():
-				deliveredMsgs[e.channelID]++
-				ticker.Reset(timout)
-
-			case <-ticker.C:
-				closer.Close()
-			}
-		}
-	}()
-
-	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
-	maxMsgs := 5000
-	minMsgs := 1000
-
-	for _, chDesc := range chDescs {
-		total := rng.Intn(maxMsgs-minMsgs) + minMsgs // total = rand[minMsgs, maxMsgs)
-		totalMsgs[ChannelID(chDesc.ID)] = total
-
-		go func(cID ChannelID, n int) {
-			for i := 0; i < n; i++ {
-				peerQueue.enqueue() <- Envelope{
-					channelID: cID,
-					Message:   &testMessage{Value: "foo"}, // 5 bytes
-				}
-			}
-		}(ChannelID(chDesc.ID), total)
-	}
-
-	// wait for dequeueing to complete
-	<-closer.Done()
-
-	// close queue and wait for cleanup
-	peerQueue.close()
-	<-peerQueue.closed()
-
-	var (
-		sum    float64
-		stdDev float64
-	)
-
-	for _, chDesc := range peerQueue.chDescs {
-		chID := ChannelID(chDesc.ID)
-		require.Zero(t, peerQueue.deficits[chID], "expected flow deficit to be zero")
-		require.Len(t, peerQueue.buffer[chID], 0, "expected flow queue to be empty")
-
-		total := totalMsgs[chID]
-		delivered := deliveredMsgs[chID]
-		successRate := float64(delivered) / float64(total)
-
-		sum += successRate
-		successRates[chID] = successRate
-
-		// require some messages dropped
-		require.Less(t, delivered, total, "expected some messages to be dropped")
-		require.Less(t, successRate, 1.0, "expected a success rate below 100%")
-	}
-
-	require.Zero(t, peerQueue.size, "expected scheduler size to be zero")
-
-	numFlows := float64(len(peerQueue.buffer))
-	mean := sum / numFlows
-
-	for _, successRate := range successRates {
-		stdDev += math.Pow(successRate-mean, 2)
-	}
-
-	stdDev = math.Sqrt(stdDev / numFlows)
-	require.Less(t, stdDev, 0.02, "expected success rate standard deviation to be less than 2%")
-}
-
-func TestWDRRQueue_DecreasingWeights(t *testing.T) {
-	chDescs := []ChannelDescriptor{
-		{ID: 0x01, Priority: 18, MaxSendBytes: 4},
-		{ID: 0x02, Priority: 10, MaxSendBytes: 4},
-		{ID: 0x03, Priority: 2, MaxSendBytes: 4},
-		{ID: 0x04, Priority: 1, MaxSendBytes: 4},
-		{ID: 0x05, Priority: 1, MaxSendBytes: 4},
-		{ID: 0x06, Priority: 1, MaxSendBytes: 4},
-	}
-
-	peerQueue := newWDRRScheduler(log.NewNopLogger(), NopMetrics(), chDescs, 0, 0, 500)
-	peerQueue.start()
-
-	totalMsgs := make(map[ChannelID]int)
-	deliveredMsgs := make(map[ChannelID]int)
-	successRates := make(map[ChannelID]float64)
-
-	for _, chDesc := range chDescs {
-		total := 1000
-		totalMsgs[ChannelID(chDesc.ID)] = total
-
-		go func(cID ChannelID, n int) {
-			for i := 0; i < n; i++ {
-				peerQueue.enqueue() <- Envelope{
-					channelID: cID,
-					Message:   &testMessage{Value: "foo"}, // 5 bytes
-				}
-			}
-		}(ChannelID(chDesc.ID), total)
-	}
-
-	closer := tmsync.NewCloser()
-
-	go func() {
-		timout := 20 * time.Second
-		ticker := time.NewTicker(timout)
-		defer ticker.Stop()
-
-		for {
-			select {
-			case e := <-peerQueue.dequeue():
-				deliveredMsgs[e.channelID]++
-				ticker.Reset(timout)
-
-			case <-ticker.C:
-				closer.Close()
-			}
-		}
-	}()
-
-	// wait for dequeueing to complete
-	<-closer.Done()
-
-	// close queue and wait for cleanup
-	peerQueue.close()
-	<-peerQueue.closed()
-
-	for i, chDesc := range peerQueue.chDescs {
-		chID := ChannelID(chDesc.ID)
-		require.Zero(t, peerQueue.deficits[chID], "expected flow deficit to be zero")
-		require.Len(t, peerQueue.buffer[chID], 0, "expected flow queue to be empty")
-
-		total := totalMsgs[chID]
-		delivered := deliveredMsgs[chID]
-		successRate := float64(delivered) / float64(total)
-
-		successRates[chID] = successRate
-
-		// Require some messages dropped. Note, the top weighted flows may not have
-		// any dropped if lower priority non-empty queues always exist.
-		if i > 2 {
-			require.Less(t, delivered, total, "expected some messages to be dropped")
-			require.Less(t, successRate, 1.0, "expected a success rate below 100%")
-		}
-	}
-
-	require.Zero(t, peerQueue.size, "expected scheduler size to be zero")
-
-	// require channel 0x01 to have the highest success rate due to its weight
-	ch01Rate := successRates[ChannelID(chDescs[0].ID)]
-	for i := 1; i < len(chDescs); i++ {
-		require.GreaterOrEqual(t, ch01Rate, successRates[ChannelID(chDescs[i].ID)])
-	}
-
-	// require channel 0x02 to have the 2nd highest success rate due to its weight
-	ch02Rate := successRates[ChannelID(chDescs[1].ID)]
-	for i := 2; i < len(chDescs); i++ {
-		require.GreaterOrEqual(t, ch02Rate, successRates[ChannelID(chDescs[i].ID)])
-	}
-
-	// require channel 0x03 to have the 3rd highest success rate due to its weight
-	ch03Rate := successRates[ChannelID(chDescs[2].ID)]
-	for i := 3; i < len(chDescs); i++ {
-		require.GreaterOrEqual(t, ch03Rate, successRates[ChannelID(chDescs[i].ID)])
-	}
-}
diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index 0a2d39665f..21b3ebe0aa 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -15,7 +15,7 @@ var (
 	// separate testnet for each combination (Cartesian product) of options.
 	testnetCombinations = map[string][]interface{}{
 		"topology":      {"single", "quad", "large"},
-		"queueType":     {"priority"}, // "fifo", "wdrr"
+		"queueType":     {"priority"}, // "fifo"
 		"initialHeight": {0, 1000},
 		"initialState": {
 			map[string]string{},
diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go
index 3a75b169e6..1daa8b87ca 100644
--- a/test/e2e/pkg/testnet.go
+++ b/test/e2e/pkg/testnet.go
@@ -347,7 +347,7 @@ func (n Node) Validate(testnet Testnet) error {
 		return fmt.Errorf("invalid mempool version %q", n.Mempool)
 	}
 	switch n.QueueType {
-	case "", "priority", "wdrr", "fifo":
+	case "", "priority", "fifo":
 	default:
 		return fmt.Errorf("unsupported p2p queue type: %s", n.QueueType)
 	}

From 851d2e3bdeb4d5a508a67cd42b36cb0328a3f817 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 5 Oct 2021 16:23:15 -0400
Subject: [PATCH 21/57] mempool,rpc: add removetx rpc method (#7047)

Addresses one of the concerns with #7041.

Provides a mechanism (via the RPC interface) to delete a single transaction, described by its hash, from the mempool. The method returns an error if the transaction cannot be found. Once the transaction is removed it remains in the cache and cannot be resubmitted until the cache is cleared or it expires from the cache.
---
 CHANGELOG_PENDING.md                      |  2 ++
 internal/consensus/replay_stubs.go        |  1 +
 internal/mempool/cache.go                 | 12 +++++-----
 internal/mempool/mempool.go               |  4 ++++
 internal/mempool/mock/mempool.go          |  1 +
 internal/mempool/tx.go                    | 15 ------------
 internal/mempool/v0/cache_test.go         |  4 ++--
 internal/mempool/v0/clist_mempool.go      | 22 ++++++++++--------
 internal/mempool/v0/clist_mempool_test.go |  4 ++--
 internal/mempool/v0/reactor.go            |  4 ++--
 internal/mempool/v1/mempool.go            | 28 +++++++++++++++++------
 internal/mempool/v1/mempool_test.go       | 12 +++++-----
 internal/mempool/v1/reactor.go            |  4 ++--
 internal/mempool/v1/tx.go                 | 21 ++++++++---------
 internal/mempool/v1/tx_test.go            | 12 +++++-----
 internal/rpc/core/mempool.go              |  4 ++++
 internal/rpc/core/routes.go               |  1 +
 light/rpc/client.go                       |  4 ++++
 rpc/client/http/http.go                   |  8 +++++++
 rpc/client/interface.go                   |  1 +
 rpc/client/local/local.go                 |  4 ++++
 rpc/openapi/openapi.yaml                  | 25 ++++++++++++++++++++
 types/mempool.go                          | 10 ++++----
 types/tx.go                               | 12 +++++-----
 24 files changed, 137 insertions(+), 78 deletions(-)

diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md
index c44c58ef06..d80e3ae61e 100644
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -30,6 +30,8 @@ Special thanks to external contributors on this release:
 
 ### FEATURES
 
+- [mempool, rpc] \#7041  Add removeTx operation to the RPC layer. (@tychoish)
+
 ### IMPROVEMENTS
 
 ### BUG FIXES
diff --git a/internal/consensus/replay_stubs.go b/internal/consensus/replay_stubs.go
index 361ac6ec8b..bc8c11cd92 100644
--- a/internal/consensus/replay_stubs.go
+++ b/internal/consensus/replay_stubs.go
@@ -24,6 +24,7 @@ func (emptyMempool) Size() int { return 0 }
 func (emptyMempool) CheckTx(_ context.Context, _ types.Tx, _ func(*abci.Response), _ mempool.TxInfo) error {
 	return nil
 }
+func (emptyMempool) RemoveTxByKey(txKey types.TxKey) error   { return nil }
 func (emptyMempool) ReapMaxBytesMaxGas(_, _ int64) types.Txs { return types.Txs{} }
 func (emptyMempool) ReapMaxTxs(n int) types.Txs              { return types.Txs{} }
 func (emptyMempool) Update(
diff --git a/internal/mempool/cache.go b/internal/mempool/cache.go
index 43174f106f..3cd45d2bc5 100644
--- a/internal/mempool/cache.go
+++ b/internal/mempool/cache.go
@@ -31,14 +31,14 @@ var _ TxCache = (*LRUTxCache)(nil)
 type LRUTxCache struct {
 	mtx      tmsync.Mutex
 	size     int
-	cacheMap map[[TxKeySize]byte]*list.Element
+	cacheMap map[types.TxKey]*list.Element
 	list     *list.List
 }
 
 func NewLRUTxCache(cacheSize int) *LRUTxCache {
 	return &LRUTxCache{
 		size:     cacheSize,
-		cacheMap: make(map[[TxKeySize]byte]*list.Element, cacheSize),
+		cacheMap: make(map[types.TxKey]*list.Element, cacheSize),
 		list:     list.New(),
 	}
 }
@@ -53,7 +53,7 @@ func (c *LRUTxCache) Reset() {
 	c.mtx.Lock()
 	defer c.mtx.Unlock()
 
-	c.cacheMap = make(map[[TxKeySize]byte]*list.Element, c.size)
+	c.cacheMap = make(map[types.TxKey]*list.Element, c.size)
 	c.list.Init()
 }
 
@@ -61,7 +61,7 @@ func (c *LRUTxCache) Push(tx types.Tx) bool {
 	c.mtx.Lock()
 	defer c.mtx.Unlock()
 
-	key := TxKey(tx)
+	key := tx.Key()
 
 	moved, ok := c.cacheMap[key]
 	if ok {
@@ -72,7 +72,7 @@ func (c *LRUTxCache) Push(tx types.Tx) bool {
 	if c.list.Len() >= c.size {
 		front := c.list.Front()
 		if front != nil {
-			frontKey := front.Value.([TxKeySize]byte)
+			frontKey := front.Value.(types.TxKey)
 			delete(c.cacheMap, frontKey)
 			c.list.Remove(front)
 		}
@@ -88,7 +88,7 @@ func (c *LRUTxCache) Remove(tx types.Tx) {
 	c.mtx.Lock()
 	defer c.mtx.Unlock()
 
-	key := TxKey(tx)
+	key := tx.Key()
 	e := c.cacheMap[key]
 	delete(c.cacheMap, key)
 
diff --git a/internal/mempool/mempool.go b/internal/mempool/mempool.go
index d679b35067..6e3955dc3b 100644
--- a/internal/mempool/mempool.go
+++ b/internal/mempool/mempool.go
@@ -32,6 +32,10 @@ type Mempool interface {
 	// its validity and whether it should be added to the mempool.
 	CheckTx(ctx context.Context, tx types.Tx, callback func(*abci.Response), txInfo TxInfo) error
 
+	// RemoveTxByKey removes a transaction, identified by its key,
+	// from the mempool.
+	RemoveTxByKey(txKey types.TxKey) error
+
 	// ReapMaxBytesMaxGas reaps transactions from the mempool up to maxBytes
 	// bytes total with the condition that the total gasWanted must be less than
 	// maxGas.
diff --git a/internal/mempool/mock/mempool.go b/internal/mempool/mock/mempool.go
index bf9ce8bd03..8e6f0c7bfb 100644
--- a/internal/mempool/mock/mempool.go
+++ b/internal/mempool/mock/mempool.go
@@ -20,6 +20,7 @@ func (Mempool) Size() int { return 0 }
 func (Mempool) CheckTx(_ context.Context, _ types.Tx, _ func(*abci.Response), _ mempool.TxInfo) error {
 	return nil
 }
+func (Mempool) RemoveTxByKey(txKey types.TxKey) error   { return nil }
 func (Mempool) ReapMaxBytesMaxGas(_, _ int64) types.Txs { return types.Txs{} }
 func (Mempool) ReapMaxTxs(n int) types.Txs              { return types.Txs{} }
 func (Mempool) Update(
diff --git a/internal/mempool/tx.go b/internal/mempool/tx.go
index 860d3d3b41..adafdf85e3 100644
--- a/internal/mempool/tx.go
+++ b/internal/mempool/tx.go
@@ -1,24 +1,9 @@
 package mempool
 
 import (
-	"crypto/sha256"
-
 	"github.com/tendermint/tendermint/types"
 )
 
-// TxKeySize defines the size of the transaction's key used for indexing.
-const TxKeySize = sha256.Size
-
-// TxKey is the fixed length array key used as an index.
-func TxKey(tx types.Tx) [TxKeySize]byte {
-	return sha256.Sum256(tx)
-}
-
-// TxHashFromBytes returns the hash of a transaction from raw bytes.
-func TxHashFromBytes(tx []byte) []byte {
-	return types.Tx(tx).Hash()
-}
-
 // TxInfo are parameters that get passed when attempting to add a tx to the
 // mempool.
 type TxInfo struct {
diff --git a/internal/mempool/v0/cache_test.go b/internal/mempool/v0/cache_test.go
index 389c0806ca..5bf2c7603c 100644
--- a/internal/mempool/v0/cache_test.go
+++ b/internal/mempool/v0/cache_test.go
@@ -61,7 +61,7 @@ func TestCacheAfterUpdate(t *testing.T) {
 			require.NotEqual(t, len(tc.txsInCache), counter,
 				"cache larger than expected on testcase %d", tcIndex)
 
-			nodeVal := node.Value.([sha256.Size]byte)
+			nodeVal := node.Value.(types.TxKey)
 			expectedBz := sha256.Sum256([]byte{byte(tc.txsInCache[len(tc.txsInCache)-counter-1])})
 			// Reference for reading the errors:
 			// >>> sha256('\x00').hexdigest()
@@ -71,7 +71,7 @@ func TestCacheAfterUpdate(t *testing.T) {
 			// >>> sha256('\x02').hexdigest()
 			// 'dbc1b4c900ffe48d575b5da5c638040125f65db0fe3e24494b76ea986457d986'
 
-			require.Equal(t, expectedBz, nodeVal, "Equality failed on index %d, tc %d", counter, tcIndex)
+			require.EqualValues(t, expectedBz, nodeVal, "Equality failed on index %d, tc %d", counter, tcIndex)
 			counter++
 			node = node.Next()
 		}
diff --git a/internal/mempool/v0/clist_mempool.go b/internal/mempool/v0/clist_mempool.go
index f3571ede0d..7816730c1f 100644
--- a/internal/mempool/v0/clist_mempool.go
+++ b/internal/mempool/v0/clist_mempool.go
@@ -3,6 +3,7 @@ package v0
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"sync"
 	"sync/atomic"
@@ -240,7 +241,7 @@ func (mem *CListMempool) CheckTx(
 		// Note it's possible a tx is still in the cache but no longer in the mempool
 		// (eg. after committing a block, txs are removed from mempool but not cache),
 		// so we only record the sender for txs still in the mempool.
-		if e, ok := mem.txsMap.Load(mempool.TxKey(tx)); ok {
+		if e, ok := mem.txsMap.Load(tx.Key()); ok {
 			memTx := e.(*clist.CElement).Value.(*mempoolTx)
 			_, loaded := memTx.senders.LoadOrStore(txInfo.SenderID, true)
 			// TODO: consider punishing peer for dups,
@@ -327,7 +328,7 @@ func (mem *CListMempool) reqResCb(
 //  - resCbFirstTime (lock not held) if tx is valid
 func (mem *CListMempool) addTx(memTx *mempoolTx) {
 	e := mem.txs.PushBack(memTx)
-	mem.txsMap.Store(mempool.TxKey(memTx.tx), e)
+	mem.txsMap.Store(memTx.tx.Key(), e)
 	atomic.AddInt64(&mem.txsBytes, int64(len(memTx.tx)))
 	mem.metrics.TxSizeBytes.Observe(float64(len(memTx.tx)))
 }
@@ -338,7 +339,7 @@ func (mem *CListMempool) addTx(memTx *mempoolTx) {
 func (mem *CListMempool) removeTx(tx types.Tx, elem *clist.CElement, removeFromCache bool) {
 	mem.txs.Remove(elem)
 	elem.DetachPrev()
-	mem.txsMap.Delete(mempool.TxKey(tx))
+	mem.txsMap.Delete(tx.Key())
 	atomic.AddInt64(&mem.txsBytes, int64(-len(tx)))
 
 	if removeFromCache {
@@ -347,13 +348,16 @@ func (mem *CListMempool) removeTx(tx types.Tx, elem *clist.CElement, removeFromC
 }
 
 // RemoveTxByKey removes a transaction from the mempool by its TxKey index.
-func (mem *CListMempool) RemoveTxByKey(txKey [mempool.TxKeySize]byte, removeFromCache bool) {
+func (mem *CListMempool) RemoveTxByKey(txKey types.TxKey) error {
 	if e, ok := mem.txsMap.Load(txKey); ok {
 		memTx := e.(*clist.CElement).Value.(*mempoolTx)
 		if memTx != nil {
-			mem.removeTx(memTx.tx, e.(*clist.CElement), removeFromCache)
+			mem.removeTx(memTx.tx, e.(*clist.CElement), false)
+			return nil
 		}
+		return errors.New("transaction not found")
 	}
+	return errors.New("invalid transaction found")
 }
 
 func (mem *CListMempool) isFull(txSize int) error {
@@ -409,7 +413,7 @@ func (mem *CListMempool) resCbFirstTime(
 			mem.addTx(memTx)
 			mem.logger.Debug(
 				"added good transaction",
-				"tx", mempool.TxHashFromBytes(tx),
+				"tx", types.Tx(tx).Hash(),
 				"res", r,
 				"height", memTx.height,
 				"total", mem.Size(),
@@ -419,7 +423,7 @@ func (mem *CListMempool) resCbFirstTime(
 			// ignore bad transaction
 			mem.logger.Debug(
 				"rejected bad transaction",
-				"tx", mempool.TxHashFromBytes(tx),
+				"tx", types.Tx(tx).Hash(),
 				"peerID", peerP2PID,
 				"res", r,
 				"err", postCheckErr,
@@ -460,7 +464,7 @@ func (mem *CListMempool) resCbRecheck(req *abci.Request, res *abci.Response) {
 			// Good, nothing to do.
 		} else {
 			// Tx became invalidated due to newly committed block.
-			mem.logger.Debug("tx is no longer valid", "tx", mempool.TxHashFromBytes(tx), "res", r, "err", postCheckErr)
+			mem.logger.Debug("tx is no longer valid", "tx", types.Tx(tx).Hash(), "res", r, "err", postCheckErr)
 			// NOTE: we remove tx from the cache because it might be good later
 			mem.removeTx(tx, mem.recheckCursor, !mem.config.KeepInvalidTxsInCache)
 		}
@@ -598,7 +602,7 @@ func (mem *CListMempool) Update(
 		// Mempool after:
 		//   100
 		// https://github.com/tendermint/tendermint/issues/3322.
-		if e, ok := mem.txsMap.Load(mempool.TxKey(tx)); ok {
+		if e, ok := mem.txsMap.Load(tx.Key()); ok {
 			mem.removeTx(tx, e.(*clist.CElement), false)
 		}
 	}
diff --git a/internal/mempool/v0/clist_mempool_test.go b/internal/mempool/v0/clist_mempool_test.go
index e55942e484..b61a8333e1 100644
--- a/internal/mempool/v0/clist_mempool_test.go
+++ b/internal/mempool/v0/clist_mempool_test.go
@@ -544,9 +544,9 @@ func TestMempoolTxsBytes(t *testing.T) {
 	err = mp.CheckTx(context.Background(), []byte{0x06}, nil, mempool.TxInfo{})
 	require.NoError(t, err)
 	assert.EqualValues(t, 9, mp.SizeBytes())
-	mp.RemoveTxByKey(mempool.TxKey([]byte{0x07}), true)
+	assert.Error(t, mp.RemoveTxByKey(types.Tx([]byte{0x07}).Key()))
 	assert.EqualValues(t, 9, mp.SizeBytes())
-	mp.RemoveTxByKey(mempool.TxKey([]byte{0x06}), true)
+	assert.NoError(t, mp.RemoveTxByKey(types.Tx([]byte{0x06}).Key()))
 	assert.EqualValues(t, 8, mp.SizeBytes())
 
 }
diff --git a/internal/mempool/v0/reactor.go b/internal/mempool/v0/reactor.go
index b8aac3b5c1..80362a04fd 100644
--- a/internal/mempool/v0/reactor.go
+++ b/internal/mempool/v0/reactor.go
@@ -171,7 +171,7 @@ func (r *Reactor) handleMempoolMessage(envelope p2p.Envelope) error {
 
 		for _, tx := range protoTxs {
 			if err := r.mempool.CheckTx(context.Background(), types.Tx(tx), nil, txInfo); err != nil {
-				logger.Error("checktx failed for tx", "tx", fmt.Sprintf("%X", mempool.TxHashFromBytes(tx)), "err", err)
+				logger.Error("checktx failed for tx", "tx", fmt.Sprintf("%X", types.Tx(tx).Hash()), "err", err)
 			}
 		}
 
@@ -378,7 +378,7 @@ func (r *Reactor) broadcastTxRoutine(peerID types.NodeID, closer *tmsync.Closer)
 			}
 			r.Logger.Debug(
 				"gossiped tx to peer",
-				"tx", fmt.Sprintf("%X", mempool.TxHashFromBytes(memTx.tx)),
+				"tx", fmt.Sprintf("%X", memTx.tx.Hash()),
 				"peer", peerID,
 			)
 		}
diff --git a/internal/mempool/v1/mempool.go b/internal/mempool/v1/mempool.go
index 34e5241596..a12fbc51ba 100644
--- a/internal/mempool/v1/mempool.go
+++ b/internal/mempool/v1/mempool.go
@@ -3,6 +3,7 @@ package v1
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"sync/atomic"
 	"time"
@@ -256,7 +257,7 @@ func (txmp *TxMempool) CheckTx(
 		return err
 	}
 
-	txHash := mempool.TxKey(tx)
+	txHash := tx.Key()
 
 	// We add the transaction to the mempool's cache and if the transaction already
 	// exists, i.e. false is returned, then we check if we've seen this transaction
@@ -304,6 +305,19 @@ func (txmp *TxMempool) CheckTx(
 	return nil
 }
 
+func (txmp *TxMempool) RemoveTxByKey(txKey types.TxKey) error {
+	txmp.Lock()
+	defer txmp.Unlock()
+
+	// remove the committed transaction from the transaction store and indexes
+	if wtx := txmp.txStore.GetTxByHash(txKey); wtx != nil {
+		txmp.removeTx(wtx, false)
+		return nil
+	}
+
+	return errors.New("transaction not found")
+}
+
 // Flush flushes out the mempool. It acquires a read-lock, fetches all the
 // transactions currently in the transaction store and removes each transaction
 // from the store and all indexes and finally resets the cache.
@@ -451,7 +465,7 @@ func (txmp *TxMempool) Update(
 		}
 
 		// remove the committed transaction from the transaction store and indexes
-		if wtx := txmp.txStore.GetTxByHash(mempool.TxKey(tx)); wtx != nil {
+		if wtx := txmp.txStore.GetTxByHash(tx.Key()); wtx != nil {
 			txmp.removeTx(wtx, false)
 		}
 	}
@@ -629,7 +643,7 @@ func (txmp *TxMempool) defaultTxCallback(req *abci.Request, res *abci.Response)
 		tx := req.GetCheckTx().Tx
 		wtx := txmp.recheckCursor.Value.(*WrappedTx)
 		if !bytes.Equal(tx, wtx.tx) {
-			panic(fmt.Sprintf("re-CheckTx transaction mismatch; got: %X, expected: %X", wtx.tx.Hash(), mempool.TxKey(tx)))
+			panic(fmt.Sprintf("re-CheckTx transaction mismatch; got: %X, expected: %X", wtx.tx.Hash(), types.Tx(tx).Key()))
 		}
 
 		// Only evaluate transactions that have not been removed. This can happen
@@ -647,7 +661,7 @@ func (txmp *TxMempool) defaultTxCallback(req *abci.Request, res *abci.Response)
 				txmp.logger.Debug(
 					"existing transaction no longer valid; failed re-CheckTx callback",
 					"priority", wtx.priority,
-					"tx", fmt.Sprintf("%X", mempool.TxHashFromBytes(wtx.tx)),
+					"tx", fmt.Sprintf("%X", wtx.tx.Hash()),
 					"err", err,
 					"code", checkTxRes.CheckTx.Code,
 				)
@@ -784,13 +798,13 @@ func (txmp *TxMempool) removeTx(wtx *WrappedTx, removeFromCache bool) {
 // the height and time based indexes.
 func (txmp *TxMempool) purgeExpiredTxs(blockHeight int64) {
 	now := time.Now()
-	expiredTxs := make(map[[mempool.TxKeySize]byte]*WrappedTx)
+	expiredTxs := make(map[types.TxKey]*WrappedTx)
 
 	if txmp.config.TTLNumBlocks > 0 {
 		purgeIdx := -1
 		for i, wtx := range txmp.heightIndex.txs {
 			if (blockHeight - wtx.height) > txmp.config.TTLNumBlocks {
-				expiredTxs[mempool.TxKey(wtx.tx)] = wtx
+				expiredTxs[wtx.tx.Key()] = wtx
 				purgeIdx = i
 			} else {
 				// since the index is sorted, we know no other txs can be be purged
@@ -807,7 +821,7 @@ func (txmp *TxMempool) purgeExpiredTxs(blockHeight int64) {
 		purgeIdx := -1
 		for i, wtx := range txmp.timestampIndex.txs {
 			if now.Sub(wtx.timestamp) > txmp.config.TTLDuration {
-				expiredTxs[mempool.TxKey(wtx.tx)] = wtx
+				expiredTxs[wtx.tx.Key()] = wtx
 				purgeIdx = i
 			} else {
 				// since the index is sorted, we know no other txs can be be purged
diff --git a/internal/mempool/v1/mempool_test.go b/internal/mempool/v1/mempool_test.go
index 3b7eb02d03..8bed5520a5 100644
--- a/internal/mempool/v1/mempool_test.go
+++ b/internal/mempool/v1/mempool_test.go
@@ -226,10 +226,10 @@ func TestTxMempool_ReapMaxBytesMaxGas(t *testing.T) {
 	require.Equal(t, len(tTxs), txmp.Size())
 	require.Equal(t, int64(5690), txmp.SizeBytes())
 
-	txMap := make(map[[mempool.TxKeySize]byte]testTx)
+	txMap := make(map[types.TxKey]testTx)
 	priorities := make([]int64, len(tTxs))
 	for i, tTx := range tTxs {
-		txMap[mempool.TxKey(tTx.tx)] = tTx
+		txMap[tTx.tx.Key()] = tTx
 		priorities[i] = tTx.priority
 	}
 
@@ -241,7 +241,7 @@ func TestTxMempool_ReapMaxBytesMaxGas(t *testing.T) {
 	ensurePrioritized := func(reapedTxs types.Txs) {
 		reapedPriorities := make([]int64, len(reapedTxs))
 		for i, rTx := range reapedTxs {
-			reapedPriorities[i] = txMap[mempool.TxKey(rTx)].priority
+			reapedPriorities[i] = txMap[rTx.Key()].priority
 		}
 
 		require.Equal(t, priorities[:len(reapedPriorities)], reapedPriorities)
@@ -276,10 +276,10 @@ func TestTxMempool_ReapMaxTxs(t *testing.T) {
 	require.Equal(t, len(tTxs), txmp.Size())
 	require.Equal(t, int64(5690), txmp.SizeBytes())
 
-	txMap := make(map[[mempool.TxKeySize]byte]testTx)
+	txMap := make(map[types.TxKey]testTx)
 	priorities := make([]int64, len(tTxs))
 	for i, tTx := range tTxs {
-		txMap[mempool.TxKey(tTx.tx)] = tTx
+		txMap[tTx.tx.Key()] = tTx
 		priorities[i] = tTx.priority
 	}
 
@@ -291,7 +291,7 @@ func TestTxMempool_ReapMaxTxs(t *testing.T) {
 	ensurePrioritized := func(reapedTxs types.Txs) {
 		reapedPriorities := make([]int64, len(reapedTxs))
 		for i, rTx := range reapedTxs {
-			reapedPriorities[i] = txMap[mempool.TxKey(rTx)].priority
+			reapedPriorities[i] = txMap[rTx.Key()].priority
 		}
 
 		require.Equal(t, priorities[:len(reapedPriorities)], reapedPriorities)
diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go
index 75f89d07e2..eff5b7ec05 100644
--- a/internal/mempool/v1/reactor.go
+++ b/internal/mempool/v1/reactor.go
@@ -178,7 +178,7 @@ func (r *Reactor) handleMempoolMessage(envelope p2p.Envelope) error {
 
 		for _, tx := range protoTxs {
 			if err := r.mempool.CheckTx(context.Background(), types.Tx(tx), nil, txInfo); err != nil {
-				logger.Error("checktx failed for tx", "tx", fmt.Sprintf("%X", mempool.TxHashFromBytes(tx)), "err", err)
+				logger.Error("checktx failed for tx", "tx", fmt.Sprintf("%X", types.Tx(tx).Hash()), "err", err)
 			}
 		}
 
@@ -386,7 +386,7 @@ func (r *Reactor) broadcastTxRoutine(peerID types.NodeID, closer *tmsync.Closer)
 			}
 			r.Logger.Debug(
 				"gossiped tx to peer",
-				"tx", fmt.Sprintf("%X", mempool.TxHashFromBytes(memTx.tx)),
+				"tx", fmt.Sprintf("%X", memTx.tx.Hash()),
 				"peer", peerID,
 			)
 		}
diff --git a/internal/mempool/v1/tx.go b/internal/mempool/v1/tx.go
index 15173b91f0..c5b7ca82f6 100644
--- a/internal/mempool/v1/tx.go
+++ b/internal/mempool/v1/tx.go
@@ -6,7 +6,6 @@ import (
 
 	"github.com/tendermint/tendermint/internal/libs/clist"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/mempool"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -17,7 +16,7 @@ type WrappedTx struct {
 	tx types.Tx
 
 	// hash defines the transaction hash and the primary key used in the mempool
-	hash [mempool.TxKeySize]byte
+	hash types.TxKey
 
 	// height defines the height at which the transaction was validated at
 	height int64
@@ -66,14 +65,14 @@ func (wtx *WrappedTx) Size() int {
 //   need mutative access.
 type TxStore struct {
 	mtx       tmsync.RWMutex
-	hashTxs   map[[mempool.TxKeySize]byte]*WrappedTx // primary index
-	senderTxs map[string]*WrappedTx                  // sender is defined by the ABCI application
+	hashTxs   map[types.TxKey]*WrappedTx // primary index
+	senderTxs map[string]*WrappedTx      // sender is defined by the ABCI application
 }
 
 func NewTxStore() *TxStore {
 	return &TxStore{
 		senderTxs: make(map[string]*WrappedTx),
-		hashTxs:   make(map[[mempool.TxKeySize]byte]*WrappedTx),
+		hashTxs:   make(map[types.TxKey]*WrappedTx),
 	}
 }
 
@@ -110,7 +109,7 @@ func (txs *TxStore) GetTxBySender(sender string) *WrappedTx {
 }
 
 // GetTxByHash returns a *WrappedTx by the transaction's hash.
-func (txs *TxStore) GetTxByHash(hash [mempool.TxKeySize]byte) *WrappedTx {
+func (txs *TxStore) GetTxByHash(hash types.TxKey) *WrappedTx {
 	txs.mtx.RLock()
 	defer txs.mtx.RUnlock()
 
@@ -119,7 +118,7 @@ func (txs *TxStore) GetTxByHash(hash [mempool.TxKeySize]byte) *WrappedTx {
 
 // IsTxRemoved returns true if a transaction by hash is marked as removed and
 // false otherwise.
-func (txs *TxStore) IsTxRemoved(hash [mempool.TxKeySize]byte) bool {
+func (txs *TxStore) IsTxRemoved(hash types.TxKey) bool {
 	txs.mtx.RLock()
 	defer txs.mtx.RUnlock()
 
@@ -142,7 +141,7 @@ func (txs *TxStore) SetTx(wtx *WrappedTx) {
 		txs.senderTxs[wtx.sender] = wtx
 	}
 
-	txs.hashTxs[mempool.TxKey(wtx.tx)] = wtx
+	txs.hashTxs[wtx.tx.Key()] = wtx
 }
 
 // RemoveTx removes a *WrappedTx from the transaction store. It deletes all
@@ -155,13 +154,13 @@ func (txs *TxStore) RemoveTx(wtx *WrappedTx) {
 		delete(txs.senderTxs, wtx.sender)
 	}
 
-	delete(txs.hashTxs, mempool.TxKey(wtx.tx))
+	delete(txs.hashTxs, wtx.tx.Key())
 	wtx.removed = true
 }
 
 // TxHasPeer returns true if a transaction by hash has a given peer ID and false
 // otherwise. If the transaction does not exist, false is returned.
-func (txs *TxStore) TxHasPeer(hash [mempool.TxKeySize]byte, peerID uint16) bool {
+func (txs *TxStore) TxHasPeer(hash types.TxKey, peerID uint16) bool {
 	txs.mtx.RLock()
 	defer txs.mtx.RUnlock()
 
@@ -179,7 +178,7 @@ func (txs *TxStore) TxHasPeer(hash [mempool.TxKeySize]byte, peerID uint16) bool
 // We return true if we've already recorded the given peer for this transaction
 // and false otherwise. If the transaction does not exist by hash, we return
 // (nil, false).
-func (txs *TxStore) GetOrSetPeerByTxHash(hash [mempool.TxKeySize]byte, peerID uint16) (*WrappedTx, bool) {
+func (txs *TxStore) GetOrSetPeerByTxHash(hash types.TxKey, peerID uint16) (*WrappedTx, bool) {
 	txs.mtx.Lock()
 	defer txs.mtx.Unlock()
 
diff --git a/internal/mempool/v1/tx_test.go b/internal/mempool/v1/tx_test.go
index c5d488669c..fb4beafab8 100644
--- a/internal/mempool/v1/tx_test.go
+++ b/internal/mempool/v1/tx_test.go
@@ -8,7 +8,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
-	"github.com/tendermint/tendermint/internal/mempool"
+	"github.com/tendermint/tendermint/types"
 )
 
 func TestTxStore_GetTxBySender(t *testing.T) {
@@ -39,7 +39,7 @@ func TestTxStore_GetTxByHash(t *testing.T) {
 		timestamp: time.Now(),
 	}
 
-	key := mempool.TxKey(wtx.tx)
+	key := wtx.tx.Key()
 	res := txs.GetTxByHash(key)
 	require.Nil(t, res)
 
@@ -58,7 +58,7 @@ func TestTxStore_SetTx(t *testing.T) {
 		timestamp: time.Now(),
 	}
 
-	key := mempool.TxKey(wtx.tx)
+	key := wtx.tx.Key()
 	txs.SetTx(wtx)
 
 	res := txs.GetTxByHash(key)
@@ -81,10 +81,10 @@ func TestTxStore_GetOrSetPeerByTxHash(t *testing.T) {
 		timestamp: time.Now(),
 	}
 
-	key := mempool.TxKey(wtx.tx)
+	key := wtx.tx.Key()
 	txs.SetTx(wtx)
 
-	res, ok := txs.GetOrSetPeerByTxHash(mempool.TxKey([]byte("test_tx_2")), 15)
+	res, ok := txs.GetOrSetPeerByTxHash(types.Tx([]byte("test_tx_2")).Key(), 15)
 	require.Nil(t, res)
 	require.False(t, ok)
 
@@ -110,7 +110,7 @@ func TestTxStore_RemoveTx(t *testing.T) {
 
 	txs.SetTx(wtx)
 
-	key := mempool.TxKey(wtx.tx)
+	key := wtx.tx.Key()
 	res := txs.GetTxByHash(key)
 	require.NotNil(t, res)
 
diff --git a/internal/rpc/core/mempool.go b/internal/rpc/core/mempool.go
index 6cd05348f7..c20f020328 100644
--- a/internal/rpc/core/mempool.go
+++ b/internal/rpc/core/mempool.go
@@ -151,3 +151,7 @@ func (env *Environment) CheckTx(ctx *rpctypes.Context, tx types.Tx) (*coretypes.
 	}
 	return &coretypes.ResultCheckTx{ResponseCheckTx: *res}, nil
 }
+
+func (env *Environment) RemoveTx(ctx *rpctypes.Context, txkey types.TxKey) error {
+	return env.Mempool.RemoveTxByKey(txkey)
+}
diff --git a/internal/rpc/core/routes.go b/internal/rpc/core/routes.go
index 73eaaf14c1..fe99d2118e 100644
--- a/internal/rpc/core/routes.go
+++ b/internal/rpc/core/routes.go
@@ -28,6 +28,7 @@ func (env *Environment) GetRoutes() RoutesMap {
 		"block_results":        rpc.NewRPCFunc(env.BlockResults, "height", true),
 		"commit":               rpc.NewRPCFunc(env.Commit, "height", true),
 		"check_tx":             rpc.NewRPCFunc(env.CheckTx, "tx", true),
+		"remove_tx":            rpc.NewRPCFunc(env.RemoveTx, "txkey", false),
 		"tx":                   rpc.NewRPCFunc(env.Tx, "hash,prove", true),
 		"tx_search":            rpc.NewRPCFunc(env.TxSearch, "query,prove,page,per_page,order_by", false),
 		"block_search":         rpc.NewRPCFunc(env.BlockSearch, "query,page,per_page,order_by", false),
diff --git a/light/rpc/client.go b/light/rpc/client.go
index 4461028cd1..dc745542e0 100644
--- a/light/rpc/client.go
+++ b/light/rpc/client.go
@@ -212,6 +212,10 @@ func (c *Client) CheckTx(ctx context.Context, tx types.Tx) (*coretypes.ResultChe
 	return c.next.CheckTx(ctx, tx)
 }
 
+func (c *Client) RemoveTx(ctx context.Context, txKey types.TxKey) error {
+	return c.next.RemoveTx(ctx, txKey)
+}
+
 func (c *Client) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) {
 	return c.next.NetInfo(ctx)
 }
diff --git a/rpc/client/http/http.go b/rpc/client/http/http.go
index 65d0f434b9..d0c1d56218 100644
--- a/rpc/client/http/http.go
+++ b/rpc/client/http/http.go
@@ -315,6 +315,14 @@ func (c *baseRPCClient) CheckTx(ctx context.Context, tx types.Tx) (*coretypes.Re
 	return result, nil
 }
 
+func (c *baseRPCClient) RemoveTx(ctx context.Context, txKey types.TxKey) error {
+	_, err := c.caller.Call(ctx, "remove_tx", map[string]interface{}{"tx_key": txKey}, nil)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 func (c *baseRPCClient) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) {
 	result := new(coretypes.ResultNetInfo)
 	_, err := c.caller.Call(ctx, "net_info", map[string]interface{}{}, result)
diff --git a/rpc/client/interface.go b/rpc/client/interface.go
index 7b6a9bd20a..474eb99372 100644
--- a/rpc/client/interface.go
+++ b/rpc/client/interface.go
@@ -146,6 +146,7 @@ type MempoolClient interface {
 	UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error)
 	NumUnconfirmedTxs(context.Context) (*coretypes.ResultUnconfirmedTxs, error)
 	CheckTx(context.Context, types.Tx) (*coretypes.ResultCheckTx, error)
+	RemoveTx(context.Context, types.TxKey) error
 }
 
 // EvidenceClient is used for submitting an evidence of the malicious
diff --git a/rpc/client/local/local.go b/rpc/client/local/local.go
index 108510b023..21ca6e6f1a 100644
--- a/rpc/client/local/local.go
+++ b/rpc/client/local/local.go
@@ -116,6 +116,10 @@ func (c *Local) CheckTx(ctx context.Context, tx types.Tx) (*coretypes.ResultChec
 	return c.env.CheckTx(c.ctx, tx)
 }
 
+func (c *Local) RemoveTx(ctx context.Context, txKey types.TxKey) error {
+	return c.env.Mempool.RemoveTxByKey(txKey)
+}
+
 func (c *Local) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) {
 	return c.env.NetInfo(c.ctx)
 }
diff --git a/rpc/openapi/openapi.yaml b/rpc/openapi/openapi.yaml
index a32d449863..83d85be8fa 100644
--- a/rpc/openapi/openapi.yaml
+++ b/rpc/openapi/openapi.yaml
@@ -237,6 +237,31 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/ErrorResponse"
+
+  /remove_tx:
+    get:
+      summary: Removes a transaction from the mempool.
+      tags:
+        - TxKey
+      operationId: remove_tx
+      parameters:
+        - in: query
+          name: txKey
+          required: true
+          schema:
+            type: string
+            example: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+          description: The transaction key
+      responses:
+        "200":
+          description: empty response.
+        "500":
+          description: empty error.
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/ErrorResponse"
+
   /subscribe:
     get:
       summary: Subscribe for events via WebSocket.
diff --git a/types/mempool.go b/types/mempool.go
index c739796af2..fa0f8a2082 100644
--- a/types/mempool.go
+++ b/types/mempool.go
@@ -1,14 +1,16 @@
 package types
 
 import (
+	"crypto/sha256"
 	"errors"
 	"fmt"
 )
 
-var (
-	// ErrTxInCache is returned to the client if we saw tx earlier
-	ErrTxInCache = errors.New("tx already exists in cache")
-)
+// ErrTxInCache is returned to the client if we saw tx earlier
+var ErrTxInCache = errors.New("tx already exists in cache")
+
+// TxKey is the fixed length array key used as an index.
+type TxKey [sha256.Size]byte
 
 // ErrTxTooLarge defines an error when a transaction is too big to be sent in a
 // message to other peers.
diff --git a/types/tx.go b/types/tx.go
index 92df92f13c..19ee41dace 100644
--- a/types/tx.go
+++ b/types/tx.go
@@ -2,6 +2,7 @@ package types
 
 import (
 	"bytes"
+	"crypto/sha256"
 	"errors"
 	"fmt"
 
@@ -16,15 +17,14 @@ import (
 // Might we want types here ?
 type Tx []byte
 
+// Key produces a fixed-length key for use in indexing.
+func (tx Tx) Key() TxKey { return sha256.Sum256(tx) }
+
 // Hash computes the TMHASH hash of the wire encoded transaction.
-func (tx Tx) Hash() []byte {
-	return tmhash.Sum(tx)
-}
+func (tx Tx) Hash() []byte { return tmhash.Sum(tx) }
 
 // String returns the hex-encoded transaction as a string.
-func (tx Tx) String() string {
-	return fmt.Sprintf("Tx{%X}", []byte(tx))
-}
+func (tx Tx) String() string { return fmt.Sprintf("Tx{%X}", []byte(tx)) }
 
 // Txs is a slice of Tx.
 type Txs []Tx

From 109814c85aa93ca735c63e62f55cd825b75808ac Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Tue, 5 Oct 2021 14:10:11 -0700
Subject: [PATCH 22/57] Clarify decision record for ADR-065. (#7062)

While discussing a question about the indexing interface (#7044), we found some
confusion about the intent of the design decisions in ADR 065.

Based on discussion with the original authors of the ADR, this commit adds some
language to the Decisions section to spell out the intentions more clearly, and
to call out future work that this ADR did not explicitly decide about.
---
 .../adr-065-custom-event-indexing.md          | 34 +++++++++++++++----
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/docs/architecture/adr-065-custom-event-indexing.md b/docs/architecture/adr-065-custom-event-indexing.md
index b5c86ecfaf..83a96de48d 100644
--- a/docs/architecture/adr-065-custom-event-indexing.md
+++ b/docs/architecture/adr-065-custom-event-indexing.md
@@ -25,6 +25,7 @@
 - April 28, 2021: Specify search capabilities are only supported through the KV indexer (@marbar3778)
 - May 19, 2021: Update the SQL schema and the eventsink interface (@jayt106)
 - Aug 30, 2021: Update the SQL schema and the psql implementation (@creachadair)
+- Oct 5, 2021: Clarify goals and implementation changes (@creachadair)
 
 ## Status
 
@@ -73,19 +74,38 @@ the database used.
 We will adopt a similar approach to that of the Cosmos SDK's `KVStore` state
 listening described in [ADR-038](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-038-state-listening.md).
 
-Namely, we will perform the following:
+We will implement the following changes:
 
 - Introduce a new interface, `EventSink`, that all data sinks must implement.
 - Augment the existing `tx_index.indexer` configuration to now accept a series
-  of one or more indexer types, i.e sinks.
+  of one or more indexer types, i.e., sinks.
 - Combine the current `TxIndexer` and `BlockIndexer` into a single `KVEventSink`
   that implements the `EventSink` interface.
-- Introduce an additional `EventSink` that is backed by [PostgreSQL](https://www.postgresql.org/).
-  - Implement the necessary schemas to support both block and transaction event
-  indexing.
+- Introduce an additional `EventSink` implementation that is backed by
+  [PostgreSQL](https://www.postgresql.org/).
+  - Implement the necessary schemas to support both block and transaction event indexing.
 - Update `IndexerService` to use a series of `EventSinks`.
-- Proxy queries to the relevant sink's native query layer.
-- Update all relevant RPC methods.
+
+In addition:
+
+- The Postgres indexer implementation will _not_ implement the proprietary `kv`
+  query language. Users wishing to write queries against the Postgres indexer
+  will connect to the underlying DBMS directly and use SQL queries based on the
+  indexing schema.
+
+  Future custom indexer implementations will not be required to support the
+  proprietary query language either.
+
+- For now, the existing `kv` indexer will be left in place with its current
+  query support, but will be marked as deprecated in a subsequent release, and
+  the documentation will be updated to encourage users who need to query the
+  event index to migrate to the Postgres indexer.
+
+- In the future we may remove the `kv` indexer entirely, or replace it with a
+  different implementation; that decision is deferred as future work.
+
+- In the future, we may remove the index query endpoints from the RPC service
+  entirely; that decision is deferred as future work, but recommended.
 
 
 ## Detailed Design

From 72aee478471f74222994ee92dcbeb600c84fa8cd Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Wed, 6 Oct 2021 00:08:54 -0400
Subject: [PATCH 23/57] ci: 0.35.x nightly should run from master and checkout
 the release branch (#7067)

Nightly branches run CI from master branch, and the configuration misses checking out the correct ref.
---
 .github/workflows/e2e-nightly-35x.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/e2e-nightly-35x.yml b/.github/workflows/e2e-nightly-35x.yml
index b78812e925..13d4b3dc83 100644
--- a/.github/workflows/e2e-nightly-35x.yml
+++ b/.github/workflows/e2e-nightly-35x.yml
@@ -26,6 +26,8 @@ jobs:
           go-version: '1.17'
 
       - uses: actions/checkout@v2.3.4
+        with:
+          ref: 'v0.35.x'
 
       - name: Build
         working-directory: test/e2e

From 0ef1a12186ab64a02f0005e3add1f2045e6afe84 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Wed, 6 Oct 2021 00:11:19 -0400
Subject: [PATCH 24/57] ci: fix p2p configuration for e2e tests (#7066)

My earlier p2p cleanup code removed support for the p2p tests from the
e2e generator and runner, but missed removing the CI
configuration. This patch remedies that.
---
 .github/workflows/e2e-nightly-master.yml | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/e2e-nightly-master.yml b/.github/workflows/e2e-nightly-master.yml
index 95cb859e82..28f8b3e4be 100644
--- a/.github/workflows/e2e-nightly-master.yml
+++ b/.github/workflows/e2e-nightly-master.yml
@@ -16,7 +16,6 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        p2p: ['legacy', 'new', 'hybrid']
         group: ['00', '01', '02', '03']
     runs-on: ubuntu-latest
     timeout-minutes: 60
@@ -35,11 +34,11 @@ jobs:
       - name: Generate testnets
         working-directory: test/e2e
         # When changing -g, also change the matrix groups above
-        run: ./build/generator -g 4 -d networks/nightly/${{ matrix.p2p }} -p ${{ matrix.p2p }}
+        run: ./build/generator -g 4 -d networks/nightly/
 
-      - name: Run ${{ matrix.p2p }} p2p testnets in group ${{ matrix.group }}
+      - name: Run ${{ matrix.p2p }} p2p testnets
         working-directory: test/e2e
-        run: ./run-multiple.sh networks/nightly/${{ matrix.p2p }}/*-group${{ matrix.group }}-*.toml
+        run: ./run-multiple.sh networks/nightly/*-group${{ matrix.group }}-*.toml
 
   e2e-nightly-fail-2:
     needs: e2e-nightly-test-2

From e4d6f6df096fe565b6eb70ac44c4f3873882ab64 Mon Sep 17 00:00:00 2001
From: Callum Waters <cmwaters19@gmail.com>
Date: Wed, 6 Oct 2021 11:59:21 +0200
Subject: [PATCH 25/57] docs: create separate releases doc (#7040)

---
 CONTRIBUTING.md    | 144 ----------------------------------------
 RELEASES.md        | 161 +++++++++++++++++++++++++++++++++++++++++++++
 version/version.go |   2 +-
 3 files changed, 162 insertions(+), 145 deletions(-)
 create mode 100644 RELEASES.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 33b8cf6a78..16bef07ccf 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -227,150 +227,6 @@ Fixes #nnnn
 
 Each PR should have one commit once it lands on `master`; this can be accomplished by using the "squash and merge" button on Github. Be sure to edit your commit message, though!
 
-### Release procedure
-
-#### A note about backport branches
-Tendermint's `master` branch is under active development.
-Releases are specified using tags and are built from long-lived "backport" branches.
-Each release "line" (e.g. 0.34 or 0.33) has its own long-lived backport branch,
-and the backport branches have names like `v0.34.x` or `v0.33.x`
-(literally, `x`; it is not a placeholder in this case).
-
-As non-breaking changes land on `master`, they should also be backported (cherry-picked)
-to these backport branches.
-
-We use Mergify's [backport feature](https://mergify.io/features/backports) to automatically backport
-to the needed branch. There should be a label for any backport branch that you'll be targeting.
-To notify the bot to backport a pull request, mark the pull request with
-the label `S:backport-to-<backport_branch>`.
-Once the original pull request is merged, the bot will try to cherry-pick the pull request
-to the backport branch. If the bot fails to backport, it will open a pull request.
-The author of the original pull request is responsible for solving the conflicts and
-merging the pull request.
-
-#### Creating a backport branch
-
-If this is the first release candidate for a major release, you get to have the honor of creating
-the backport branch!
-
-Note that, after creating the backport branch, you'll also need to update the tags on `master`
-so that `go mod` is able to order the branches correctly. You should tag `master` with a "dev" tag
-that is "greater than" the backport branches tags. See #6072 for more context.
-
-In the following example, we'll assume that we're making a backport branch for
-the 0.35.x line.
-
-1. Start on `master`
-2. Create the backport branch:
-   `git checkout -b v0.35.x`
-3. Go back to master and tag it as the dev branch for the _next_ major release and push it back up:
-   `git tag -a v0.36.0-dev; git push v0.36.0-dev`
-4. Create a new workflow to run the e2e nightlies for this backport branch.
-   (See https://github.com/tendermint/tendermint/blob/master/.github/workflows/e2e-nightly-34x.yml
-   for an example.)
-
-#### Release candidates
-
-Before creating an official release, especially a major release, we may want to create a
-release candidate (RC) for our friends and partners to test out. We use git tags to
-create RCs, and we build them off of backport branches.
-
-Tags for RCs should follow the "standard" release naming conventions, with `-rcX` at the end
-(for example, `v0.35.0-rc0`).
-
-(Note that branches and tags _cannot_ have the same names, so it's important that these branches
-have distinct names from the tags/release names.)
-
-If this is the first RC for a major release, you'll have to make a new backport branch (see above).
-Otherwise:
-
-1. Start from the backport branch (e.g. `v0.35.x`).
-1. Run the integration tests and the e2e nightlies
-   (which can be triggered from the Github UI;
-   e.g., https://github.com/tendermint/tendermint/actions/workflows/e2e-nightly-34x.yml).
-1. Prepare the changelog:
-   - Move the changes included in `CHANGELOG_PENDING.md` into `CHANGELOG.md`.
-   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for
-     all PRs
-   - Ensure that UPGRADING.md is up-to-date and includes notes on any breaking changes
-      or other upgrading flows.
-   - Bump TMVersionDefault version in  `version.go`
-   - Bump P2P and block protocol versions in  `version.go`, if necessary
-   - Bump ABCI protocol version in `version.go`, if necessary
-1. Open a PR with these changes against the backport branch.
-1. Once these changes have landed on the backport branch, be sure to pull them back down locally.
-2. Once you have the changes locally, create the new tag, specifying a name and a tag "message":
-   `git tag -a v0.35.0-rc0 -m "Release Candidate v0.35.0-rc0`
-3. Push the tag back up to origin:
-   `git push origin v0.35.0-rc0`
-   Now the tag should be available on the repo's releases page.
-4. Future RCs will continue to be built off of this branch.
-
-Note that this process should only be used for "true" RCs--
-release candidates that, if successful, will be the next release.
-For more experimental "RCs," create a new, short-lived branch and tag that instead.
-
-#### Major release
-
-This major release process assumes that this release was preceded by release candidates.
-If there were no release candidates, begin by creating a backport branch, as described above.
-
-1. Start on the backport branch (e.g. `v0.35.x`)
-2. Run integration tests and the e2e nightlies.
-3. Prepare the release:
-   - "Squash" changes from the changelog entries for the RCs into a single entry,
-      and add all changes included in `CHANGELOG_PENDING.md`.
-      (Squashing includes both combining all entries, as well as removing or simplifying
-      any intra-RC changes. It may also help to alphabetize the entries by package name.)
-   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for
-     all PRs
-   - Ensure that UPGRADING.md is up-to-date and includes notes on any breaking changes
-      or other upgrading flows.
-   - Bump TMVersionDefault version in  `version.go`
-   - Bump P2P and block protocol versions in  `version.go`, if necessary
-   - Bump ABCI protocol version in `version.go`, if necessary
-4. Open a PR with these changes against the backport branch.
-5. Once these changes are on the backport branch, push a tag with prepared release details.
-   This will trigger the actual release `v0.35.0`.
-   - `git tag -a v0.35.0 -m 'Release v0.35.0'`
-   - `git push origin v0.35.0`
-7. Make sure that `master` is updated with the latest `CHANGELOG.md`, `CHANGELOG_PENDING.md`, and `UPGRADING.md`.
-8. Add the release to the documentation site generator config (see
-   [DOCS_README.md](./docs/DOCS_README.md) for more details). In summary:
-   - Start on branch `master`.
-   - Add a new line at the bottom of [`docs/versions`](./docs/versions) to
-     ensure the newest release is the default for the landing page.
-   - Add a new entry to `themeConfig.versions` in
-     [`docs/.vuepress/config.js`](./docs/.vuepress/config.js) to include the
-	 release in the dropdown versions menu.
-
-#### Minor release (point releases)
-
-Minor releases are done differently from major releases: They are built off of long-lived backport branches, rather than from master.
-As non-breaking changes land on `master`, they should also be backported (cherry-picked) to these backport branches.
-
-Minor releases don't have release candidates by default, although any tricky changes may merit a release candidate.
-
-To create a minor release:
-
-1. Checkout the long-lived backport branch: `git checkout v0.35.x`
-2. Run integration tests (`make test_integrations`) and the nightlies.
-3. Check out a new branch and prepare the release:
-   - Copy `CHANGELOG_PENDING.md` to top of `CHANGELOG.md`
-   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for all issues
-   - Run `bash ./scripts/authors.sh` to get a list of authors since the latest release, and add the GitHub aliases of external contributors to the top of the CHANGELOG. To lookup an alias from an email, try `bash ./scripts/authors.sh <email>`
-   - Reset the `CHANGELOG_PENDING.md`
-   - Bump the ABCI version number, if necessary.
-     (Note that ABCI follows semver, and that ABCI versions are the only versions
-     which can change during minor releases, and only field additions are valid minor changes.)
-4. Open a PR with these changes that will land them back on `v0.35.x`
-5. Once this change has landed on the backport branch, make sure to pull it locally, then push a tag.
-   - `git tag -a v0.35.1 -m 'Release v0.35.1'`
-   - `git push origin v0.35.1`
-6. Create a pull request back to master with the CHANGELOG & version changes from the latest release.
-   - Remove all `R:minor` labels from the pull requests that were included in the release.
-   - Do not merge the backport branch into master.
-
 ## Testing
 
 ### Unit tests
diff --git a/RELEASES.md b/RELEASES.md
new file mode 100644
index 0000000000..8d9bc2b8ea
--- /dev/null
+++ b/RELEASES.md
@@ -0,0 +1,161 @@
+# Releases
+
+Tendermint uses [semantic versioning](https://semver.org/) with each release following
+a `vX.Y.Z` format. The `master` branch is used for active development and thus it's
+advisable not to build against it.
+
+The latest changes are always initially merged into `master`.
+Releases are specified using tags and are built from long-lived "backport" branches
+that are cut from `master` when the release process begins.
+Each release "line" (e.g. 0.34 or 0.33) has its own long-lived backport branch,
+and the backport branches have names like `v0.34.x` or `v0.33.x`
+(literally, `x`; it is not a placeholder in this case). Tendermint only
+maintains the last two releases at a time (the oldest release is predominantly
+just security patches).
+
+## Backporting
+
+As non-breaking changes land on `master`, they should also be backported
+to these backport branches.
+
+We use Mergify's [backport feature](https://mergify.io/features/backports) to automatically backport
+to the needed branch. There should be a label for any backport branch that you'll be targeting.
+To notify the bot to backport a pull request, mark the pull request with the label corresponding
+to the correct backport branch. For example, to backport to v0.35.x, add the label `S:backport-to-v0.35.x`.
+Once the original pull request is merged, the bot will try to cherry-pick the pull request
+to the backport branch. If the bot fails to backport, it will open a pull request.
+The author of the original pull request is responsible for solving the conflicts and
+merging the pull request.
+
+### Creating a backport branch
+
+If this is the first release candidate for a major release, you get to have the honor of creating
+the backport branch!
+
+Note that, after creating the backport branch, you'll also need to update the
+tags on `master` so that `go mod` is able to order the branches correctly. You
+should tag `master` with a "dev" tag that is "greater than" the backport
+branches tags. See [#6072](https://github.com/tendermint/tendermint/pull/6072)
+for more context.
+
+In the following example, we'll assume that we're making a backport branch for
+the 0.35.x line.
+
+1. Start on `master`
+2. Create and push the backport branch:
+   `git checkout -b v0.35.x; git push origin v0.35.x`
+3. Go back to master and tag it as the dev branch for the _next_ major release and push it back up:
+   `git tag -a v0.36.0-dev -m "Development base for Tendermint v0.36."; git push origin v0.36.0-dev`
+4. Create a new workflow (still on master) to run e2e nightlies for the new backport branch.
+   (See https://github.com/tendermint/tendermint/blob/master/.github/workflows/e2e-nightly-master.yml
+   for an example.)
+5. Add a new section to the Mergify config (`.github/mergify.yml`) to enable the
+   backport bot to work on this branch, and add a corresponding `S:backport-to-v0.35.x`
+   [label](https://github.com/tendermint/tendermint/labels) so the bot can be triggered.
+
+## Release candidates
+
+Before creating an official release, especially a major release, we may want to create a
+release candidate (RC) for our friends and partners to test out. We use git tags to
+create RCs, and we build them off of backport branches.
+
+Tags for RCs should follow the "standard" release naming conventions, with `-rcX` at the end
+(for example, `v0.35.0-rc0`).
+
+(Note that branches and tags _cannot_ have the same names, so it's important that these branches
+have distinct names from the tags/release names.)
+
+If this is the first RC for a major release, you'll have to make a new backport branch (see above).
+Otherwise:
+
+1. Start from the backport branch (e.g. `v0.35.x`).
+2. Run the integration tests and the e2e nightlies
+   (which can be triggered from the Github UI;
+   e.g., https://github.com/tendermint/tendermint/actions/workflows/e2e-nightly-34x.yml).
+3. Prepare the changelog:
+   - Move the changes included in `CHANGELOG_PENDING.md` into `CHANGELOG.md`. Each RC should have
+     it's own changelog section. These will be squashed when the final candidate is released.
+   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for
+     all PRs
+   - Ensure that `UPGRADING.md` is up-to-date and includes notes on any breaking changes
+      or other upgrading flows.
+   - Bump TMVersionDefault version in  `version.go`
+   - Bump P2P and block protocol versions in  `version.go`, if necessary.
+     Check the changelog for breaking changes in these components.
+   - Bump ABCI protocol version in `version.go`, if necessary
+4. Open a PR with these changes against the backport branch.
+5. Once these changes have landed on the backport branch, be sure to pull them back down locally.
+6. Once you have the changes locally, create the new tag, specifying a name and a tag "message":
+   `git tag -a v0.35.0-rc0 -m "Release Candidate v0.35.0-rc0`
+7. Push the tag back up to origin:
+   `git push origin v0.35.0-rc0`
+   Now the tag should be available on the repo's releases page.
+8. Future RCs will continue to be built off of this branch.
+
+Note that this process should only be used for "true" RCs--
+release candidates that, if successful, will be the next release.
+For more experimental "RCs," create a new, short-lived branch and tag that instead.
+
+## Major release
+
+This major release process assumes that this release was preceded by release candidates.
+If there were no release candidates, begin by creating a backport branch, as described above.
+
+1. Start on the backport branch (e.g. `v0.35.x`)
+2. Run integration tests (`make test_integrations`) and the e2e nightlies.
+3. Prepare the release:
+   - "Squash" changes from the changelog entries for the RCs into a single entry,
+      and add all changes included in `CHANGELOG_PENDING.md`.
+      (Squashing includes both combining all entries, as well as removing or simplifying
+      any intra-RC changes. It may also help to alphabetize the entries by package name.)
+   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for
+     all PRs
+   - Ensure that `UPGRADING.md` is up-to-date and includes notes on any breaking changes
+      or other upgrading flows.
+   - Bump TMVersionDefault version in  `version.go`
+   - Bump P2P and block protocol versions in  `version.go`, if necessary
+   - Bump ABCI protocol version in `version.go`, if necessary
+4. Open a PR with these changes against the backport branch.
+5. Once these changes are on the backport branch, push a tag with prepared release details.
+   This will trigger the actual release `v0.35.0`.
+   - `git tag -a v0.35.0 -m 'Release v0.35.0'`
+   - `git push origin v0.35.0`
+6. Make sure that `master` is updated with the latest `CHANGELOG.md`, `CHANGELOG_PENDING.md`, and `UPGRADING.md`.
+7. Add the release to the documentation site generator config (see
+   [DOCS_README.md](./docs/DOCS_README.md) for more details). In summary:
+   - Start on branch `master`.
+   - Add a new line at the bottom of [`docs/versions`](./docs/versions) to
+     ensure the newest release is the default for the landing page.
+   - Add a new entry to `themeConfig.versions` in
+     [`docs/.vuepress/config.js`](./docs/.vuepress/config.js) to include the
+	 release in the dropdown versions menu.
+
+## Minor release (point releases)
+
+Minor releases are done differently from major releases: They are built off of
+long-lived backport branches, rather than from master.  As non-breaking changes
+land on `master`, they should also be backported into these backport branches.
+
+Minor releases don't have release candidates by default, although any tricky
+changes may merit a release candidate.
+
+To create a minor release:
+
+1. Checkout the long-lived backport branch: `git checkout v0.35.x`
+2. Run integration tests (`make test_integrations`) and the nightlies.
+3. Check out a new branch and prepare the release:
+   - Copy `CHANGELOG_PENDING.md` to top of `CHANGELOG.md`
+   - Run `python ./scripts/linkify_changelog.py CHANGELOG.md` to add links for all issues
+   - Run `bash ./scripts/authors.sh` to get a list of authors since the latest release, and add the GitHub aliases of external contributors to the top of the CHANGELOG. To lookup an alias from an email, try `bash ./scripts/authors.sh <email>`
+   - Reset the `CHANGELOG_PENDING.md`
+   - Bump the TMDefaultVersion in `version.go`
+   - Bump the ABCI version number, if necessary.
+     (Note that ABCI follows semver, and that ABCI versions are the only versions
+     which can change during minor releases, and only field additions are valid minor changes.)
+4. Open a PR with these changes that will land them back on `v0.35.x`
+5. Once this change has landed on the backport branch, make sure to pull it locally, then push a tag.
+   - `git tag -a v0.35.1 -m 'Release v0.35.1'`
+   - `git push origin v0.35.1`
+6. Create a pull request back to master with the CHANGELOG & version changes from the latest release.
+   - Remove all `R:minor` labels from the pull requests that were included in the release.
+   - Do not merge the backport branch into master.
diff --git a/version/version.go b/version/version.go
index 3fb08652e5..e42952f773 100644
--- a/version/version.go
+++ b/version/version.go
@@ -10,7 +10,7 @@ const (
 
 	// TMVersionDefault is the used as the fallback version of Tendermint Core
 	// when not using git describe. It is formatted with semantic versioning.
-	TMVersionDefault = "0.34.11"
+	TMVersionDefault = "0.35.0-unreleased"
 	// ABCISemVer is the semantic version of the ABCI library
 	ABCISemVer = "0.17.0"
 

From e53f92ba9cfceb49c1588775f6a9c700c22d4c0a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 6 Oct 2021 09:14:55 -0400
Subject: [PATCH 26/57] build(deps): Bump github.com/adlio/schema from 1.1.13
 to 1.1.14 (#7069)

Bumps [github.com/adlio/schema](https://github.com/adlio/schema) from 1.1.13 to 1.1.14.
- [Release notes](https://github.com/adlio/schema/releases)
- [Commits](https://github.com/adlio/schema/compare/v1.1.13...v1.1.14)

---
updated-dependencies:
- dependency-name: github.com/adlio/schema
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

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

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 go.mod |  6 ++----
 go.sum | 62 ++++++++++++++++++++++++++++++++++++----------------------
 2 files changed, 41 insertions(+), 27 deletions(-)

diff --git a/go.mod b/go.mod
index 4eff732830..cfd8e7fe74 100644
--- a/go.mod
+++ b/go.mod
@@ -4,8 +4,7 @@ go 1.16
 
 require (
 	github.com/BurntSushi/toml v0.4.1
-	github.com/Workiva/go-datastructures v1.0.53
-	github.com/adlio/schema v1.1.13
+	github.com/adlio/schema v1.1.14
 	github.com/btcsuite/btcd v0.22.0-beta
 	github.com/btcsuite/btcutil v1.0.3-0.20201208143702-a53e38424cce
 	github.com/fortytw2/leaktest v1.3.0
@@ -20,7 +19,6 @@ require (
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/lib/pq v1.10.3
 	github.com/libp2p/go-buffer-pool v0.0.2
-	github.com/minio/highwayhash v1.0.2
 	github.com/mroth/weightedrand v0.4.1
 	github.com/oasisprotocol/curve25519-voi v0.0.0-20210609091139-0a56a4bca00b
 	github.com/ory/dockertest v3.3.5+incompatible
@@ -36,7 +34,7 @@ require (
 	github.com/tendermint/tm-db v0.6.4
 	github.com/vektra/mockery/v2 v2.9.4
 	golang.org/x/crypto v0.0.0-20210915214749-c084706c2272
-	golang.org/x/net v0.0.0-20210917221730-978cfadd31cf
+	golang.org/x/net v0.0.0-20211005001312-d4b1ae081e3b
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	google.golang.org/grpc v1.41.0
 	gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b // indirect
diff --git a/go.sum b/go.sum
index c6a87e16ff..e767033e5d 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,6 @@
 4d63.com/gochecknoglobals v0.0.0-20201008074935-acfc0b28355a h1:wFEQiK85fRsEVF0CRrPAos5LoAryUsIX1kPW/WrIqFw=
 4d63.com/gochecknoglobals v0.0.0-20201008074935-acfc0b28355a/go.mod h1:wfdC5ZjKSPr7CybKEcgJhUOgeAQW1+7WcyK8OvUilfo=
+bazil.org/fuse v0.0.0-20200407214033-5883e5a4b512/go.mod h1:FbcW6z/2VytnFDhZfumh8Ss8zxHE6qpMP5sHTRe0EaM=
 bitbucket.org/creachadair/shell v0.0.6/go.mod h1:8Qqi/cYk7vPnsOePHroKXDJYmb5x7ENhtiFtfZq8K+M=
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
@@ -52,8 +53,8 @@ contrib.go.opencensus.io/exporter/stackdriver v0.13.4/go.mod h1:aXENhDJ1Y4lIg4EU
 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
 github.com/Antonboom/errname v0.1.4 h1:lGSlI42Gm4bI1e+IITtXJXvxFM8N7naWimVFKcb0McY=
 github.com/Antonboom/errname v0.1.4/go.mod h1:jRXo3m0E0EuCnK3wbsSVH3X55Z4iTDLl6ZfCxwFj4TM=
-github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 h1:w+iIsaOQNcT7OZ575w+acHgRric5iCyQh+xv+KJ4HB8=
-github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8=
+github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8=
+github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v0.4.1 h1:GaI7EiDXDRfa8VshkTj7Fym7ha+y8/XxIgD2okUIjLw=
 github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
@@ -72,8 +73,8 @@ github.com/Masterminds/semver v1.5.0 h1:H65muMkzWKEuNDnfl9d70GUjFniHKHRbFPGBuZ3Q
 github.com/Masterminds/semver v1.5.0/go.mod h1:MB6lktGJrhw8PrUyiEoblNEGEQ+RzHPF078ddwwvV3Y=
 github.com/Masterminds/sprig v2.15.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o=
 github.com/Masterminds/sprig v2.22.0+incompatible/go.mod h1:y6hNFY5UBTIWBxnzTeuNhlNS5hqE0NB0E6fgfo2Br3o=
-github.com/Microsoft/go-winio v0.4.14 h1:+hMXMk01us9KgxGb7ftKQt2Xpf5hH/yky+TDA+qxleU=
-github.com/Microsoft/go-winio v0.4.14/go.mod h1:qXqCSQ3Xa7+6tgxaGTIe4Kpcdsi+P8jBhyzoq1bpyYA=
+github.com/Microsoft/go-winio v0.5.0 h1:Elr9Wn+sGKPlkaBvwu4mTrxtmOp3F3yV9qhaHbXGjwU=
+github.com/Microsoft/go-winio v0.5.0/go.mod h1:JPGBdM1cNvN/6ISo+n8V5iA4v8pBzdOpzfwIujj1a84=
 github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw=
 github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk=
 github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
@@ -85,10 +86,8 @@ github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMx
 github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8=
 github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
 github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
-github.com/Workiva/go-datastructures v1.0.53 h1:J6Y/52yX10Xc5JjXmGtWoSSxs3mZnGSaq37xZZh7Yig=
-github.com/Workiva/go-datastructures v1.0.53/go.mod h1:1yZL+zfsztete+ePzZz/Zb1/t5BnDuE2Ya2MMGhzP6A=
-github.com/adlio/schema v1.1.13 h1:LeNMVg5Z1FX+Qgz8tJUijBLRdcpbFUElz+d1489On98=
-github.com/adlio/schema v1.1.13/go.mod h1:L5Z7tw+7lRK1Fnpi/LT/ooCP1elkXn0krMWBQHUhEDE=
+github.com/adlio/schema v1.1.14 h1:lIjyp5/2wSuEOmeQGNPpaRsVGZRqz9A/B+PaMtEotaU=
+github.com/adlio/schema v1.1.14/go.mod h1:hQveFEMiDlG/M9yz9RAajnH5DzT6nAfqOG9YkEQU2pg=
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
 github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
 github.com/ajstarks/svgo v0.0.0-20180226025133-644b8db467af/go.mod h1:K08gAheRH3/J6wwsYMMT4xOr94bZjxIelGM0+d/wbFw=
@@ -126,6 +125,7 @@ github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+Ce
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/bits-and-blooms/bitset v1.2.0/go.mod h1:gIdJ4wp64HaoK2YrL1Q5/N7Y16edYb8uY+O0FJTyyDA=
 github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84=
 github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM=
 github.com/bkielbasa/cyclop v1.2.0 h1:7Jmnh0yL2DjKfw28p86YTd/B4lRGcNuu12sKE35sM7A=
@@ -160,9 +160,11 @@ github.com/charithe/durationcheck v0.0.8 h1:cnZrThioNW9gSV5JsRIXmkyHUbcDH7Y9hkzF
 github.com/charithe/durationcheck v0.0.8/go.mod h1:SSbRIBVfMjCi/kEB6K65XEA83D6prSM8ap1UCpNKtgg=
 github.com/chavacava/garif v0.0.0-20210405164556-e8a0a408d6af h1:spmv8nSH9h5oCQf40jt/ufBCt9j0/58u4G+rkeMqXGI=
 github.com/chavacava/garif v0.0.0-20210405164556-e8a0a408d6af/go.mod h1:Qjyv4H3//PWVzTeCezG2b9IRn6myJxJSr4TD/xo6ojU=
+github.com/checkpoint-restore/go-criu/v5 v5.0.0/go.mod h1:cfwC0EG7HMUenopBsUf9d89JlCLQIfgVcNsNN0t6T2M=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/cilium/ebpf v0.6.2/go.mod h1:4tRaxcgiL706VnOzHOdBlY8IEAIdxINsQBcU4xJJXRs=
 github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
 github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
 github.com/clbanning/mxj v1.8.4/go.mod h1:BVjHeAH+rl9rs6f+QIpeRl0tfu10SXn1pUSa5PVGJng=
@@ -173,8 +175,9 @@ github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnht
 github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
 github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
-github.com/containerd/continuity v0.0.0-20190827140505-75bee3e2ccb6 h1:NmTXa/uVnDyp0TY5MKi197+3HWcnYWfnHGyaFthlnGw=
-github.com/containerd/continuity v0.0.0-20190827140505-75bee3e2ccb6/go.mod h1:GL3xCUCBDV3CZiTSEKksMWbLE66hEyuu9qyDOOqM47Y=
+github.com/containerd/console v1.0.2/go.mod h1:ytZPjGgY2oeTkAONYafi2kSj0aYggsf8acV1PGKCbzQ=
+github.com/containerd/continuity v0.2.0 h1:j/9Wnn+hrEWjLvHuIxUU1YI5JjEjVlT2AA68cse9rwY=
+github.com/containerd/continuity v0.2.0/go.mod h1:wCYX+dRqZdImhGucXOqTQn05AhX6EUDaGEMUzTFFpLg=
 github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/etcd v3.3.13+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
@@ -192,6 +195,7 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma
 github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
 github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/cyphar/filepath-securejoin v0.2.2/go.mod h1:FpkQEhXnPnOthhzymB7CGsFk2G9VLXONKD9G7QGMM+4=
 github.com/daixiang0/gci v0.2.9 h1:iwJvwQpBZmMg31w+QQ6jsyZ54KEATn6/nfARbBNW294=
 github.com/daixiang0/gci v0.2.9/go.mod h1:+4dZ7TISfSmqfAGv59ePaHfNzgGtIkHAhhdKggP1JAc=
 github.com/davecgh/go-spew v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -253,6 +257,7 @@ github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8
 github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
 github.com/franela/goblin v0.0.0-20210519012713-85d372ac71e2/go.mod h1:VzmDKDJVZI3aJmnRI9VjAn9nJ8qPPsN1fqzr9dqInIo=
 github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
+github.com/frankban/quicktest v1.11.3/go.mod h1:wRf/ReqHper53s+kmmSZizM8NamnL3IM0I9ntUbOk+k=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/fsnotify/fsnotify v1.5.1 h1:mZcQUHVQUQWoPXXtuf9yuEXKudkV2sx1E06UadKWpgI=
@@ -574,6 +579,7 @@ github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
+github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -592,7 +598,6 @@ github.com/ldez/tagliatelle v0.2.0/go.mod h1:8s6WJQwEYHbKZDsp/LjArytKOG8qaMrKQQ3
 github.com/leodido/go-urn v1.1.0/go.mod h1:+cyI34gQWZcE1eQU7NVgKkkzdXDQHr1dBMtdAPozLkw=
 github.com/letsencrypt/pkcs11key/v4 v4.0.0/go.mod h1:EFUvBDay26dErnNb70Nd0/VW3tJiIbETBPTl9ATXQag=
 github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.2.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/lib/pq v1.8.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/lib/pq v1.9.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/lib/pq v1.10.2/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
@@ -645,7 +650,6 @@ github.com/miekg/dns v1.1.43/go.mod h1:+evo5L0630/F6ca/Z9+GAqzhjGyn8/c+TBaOyfEl0
 github.com/miekg/pkcs11 v1.0.2/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs=
 github.com/miekg/pkcs11 v1.0.3/go.mod h1:XsNlhZGX73bx86s2hdc/FuaLm2CPZJemRLMA+WTFxgs=
 github.com/minio/highwayhash v1.0.1/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
-github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
 github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
 github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
 github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI=
@@ -664,6 +668,7 @@ github.com/mitchellh/mapstructure v1.4.2 h1:6h7AQ0yhTcIsmFmnAwQls75jp2Gzs4iB8W7p
 github.com/mitchellh/mapstructure v1.4.2/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/mitchellh/reflectwalk v1.0.0/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
 github.com/mitchellh/reflectwalk v1.0.1/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw=
+github.com/moby/sys/mountinfo v0.4.1/go.mod h1:rEr8tzG/lsIZHBtN/JjGG+LMYx9eXgW2JI+6q0qou+A=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
@@ -676,6 +681,7 @@ github.com/mozilla/scribe v0.0.0-20180711195314-fb71baf557c1/go.mod h1:FIczTrinK
 github.com/mozilla/tls-observatory v0.0.0-20210609171429-7bc42856d2e5/go.mod h1:FUqVoUPHSEdDR0MnFM3Dh8AU0pZHLXUD127SAJGER/s=
 github.com/mroth/weightedrand v0.4.1 h1:rHcbUBopmi/3x4nnrvwGJBhX9d0vk+KgoLUZeDP6YyI=
 github.com/mroth/weightedrand v0.4.1/go.mod h1:3p2SIcC8al1YMzGhAIoXD+r9olo/g/cdJgAD905gyNE=
+github.com/mrunalp/fileutils v0.5.0/go.mod h1:M1WthSahJixYnrXQl/DFQuteStB1weuxD2QJNHXfbSQ=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/mwitkow/go-proto-validators v0.0.0-20180403085117-0950a7990007/go.mod h1:m2XC9Qq0AlmmVksL6FktJCdTYyLk7V3fKyp0sl1yWQo=
@@ -724,12 +730,14 @@ github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1y
 github.com/onsi/gomega v1.13.0 h1:7lLHu94wT9Ij0o6EWWclhu0aOh32VxhkwEJvzuWPeak=
 github.com/onsi/gomega v1.13.0/go.mod h1:lRk9szgn8TxENtWd0Tp4c3wjlRfMTMH27I+3Je41yGY=
 github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
-github.com/opencontainers/go-digest v1.0.0-rc1 h1:WzifXhOVOEOuFYOJAW6aQqW0TooG2iki3E3Ii+WN7gQ=
-github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.0.1 h1:JMemWkRwHx4Zj+fVxWoMCFm/8sYGGrUVojFA6h/TRcI=
 github.com/opencontainers/image-spec v1.0.1/go.mod h1:BtxoFyWECRxE4U/7sNtV5W15zMzWCbyJoFRP3s7yZA0=
-github.com/opencontainers/runc v0.1.1 h1:GlxAyO6x8rfZYN9Tt0Kti5a/cP41iuiO2yYT0IJGY8Y=
-github.com/opencontainers/runc v0.1.1/go.mod h1:qT5XzbpPznkRYVz/mWwUaVBUv2rmF59PVA73FjuZG0U=
+github.com/opencontainers/runc v1.0.2 h1:opHZMaswlyxz1OuGpBE53Dwe4/xF7EZTY0A2L/FpCOg=
+github.com/opencontainers/runc v1.0.2/go.mod h1:aTaHFFwQXuA71CiyxOdFFIorAoemI04suvGRQFzWTD0=
+github.com/opencontainers/runtime-spec v1.0.3-0.20210326190908-1c3f411f0417/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
+github.com/opencontainers/selinux v1.8.2/go.mod h1:MUIHuUEvKB1wtJjQdOyYRgOnLD2xAPP8dBsCoU0KuF8=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
 github.com/openzipkin/zipkin-go v0.2.5/go.mod h1:KpXfKdgRDnnhsxw4pNIH9Md5lyFqKUa4YDFlwRYAMyE=
@@ -748,7 +756,6 @@ github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 h1:q2e307iGHPdTGp
 github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o=
 github.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d h1:CdDQnGF8Nq9ocOS/xlSptM1N3BbrA6/kmaep5ggwaIA=
 github.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d/go.mod h1:3OzsM7FXDQlpCiw2j81fOmAwQLnZnLGXVKUzeKQXIAw=
-github.com/philhofer/fwd v1.1.1/go.mod h1:gk3iGcWd9+svBvR0sR+KPcfE+RNWozjowpeBVG3ZVNU=
 github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -832,6 +839,7 @@ github.com/sanposhiho/wastedassign/v2 v2.0.6/go.mod h1:KyZ0MWTwxxBmfwn33zh3k1dms
 github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa h1:0U2s5loxrTy6/VgfVoLuVLFJcURKLH49ie0zSch7gh4=
 github.com/sasha-s/go-deadlock v0.2.1-0.20190427202633-1595213edefa/go.mod h1:F73l+cr82YSh10GxyRI6qZiCgK64VaZjwesgfQ1/iLM=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/seccomp/libseccomp-golang v0.9.1/go.mod h1:GbW5+tmTXfcxTToHLXlScSlAvWlF4P2Ca7zGrPiEpWo=
 github.com/securego/gosec/v2 v2.8.1 h1:Tyy/nsH39TYCOkqf5HAgRE+7B5D8sHDwPdXRgFWokh8=
 github.com/securego/gosec/v2 v2.8.1/go.mod h1:pUmsq6+VyFEElJMUX+QB3p3LWNHXg1R3xh2ssVJPs8Q=
 github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
@@ -842,7 +850,6 @@ github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxr
 github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
 github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
-github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/sirupsen/logrus v1.7.0/go.mod h1:yWOB1SBYBC5VeMP7gHvWumXLIWorT60ONWic61uBYv0=
@@ -906,6 +913,7 @@ github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5Cc
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
+github.com/syndtr/gocapability v0.0.0-20200815063812-42c35b437635/go.mod h1:hkRG7XYTFWNJGYcbNJQlaLq0fg1yr4J4t/NcTQtrfww=
 github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca h1:Ld/zXl5t4+D69SiV4JoN7kkfvJdOWlPpfxrzxpLMoUk=
 github.com/syndtr/goleveldb v1.0.1-0.20200815110645-5c35d600f0ca/go.mod h1:u2MKkTVTVJWe5D1rCvame8WqhBd88EuIwODJZ1VHCPM=
 github.com/tdakkota/asciicheck v0.0.0-20200416200610-e657995f937b h1:HxLVTlqcHhFAz3nWUcuvpH7WuOMv8LQoCWmruLfFH2U=
@@ -918,7 +926,6 @@ github.com/tetafro/godot v1.4.9 h1:wsNd0RuUxISqqudFqchsSsMqsM188DoZVPBeKl87tP0=
 github.com/tetafro/godot v1.4.9/go.mod h1:LR3CJpxDVGlYOWn3ZZg1PgNZdTUvzsZWu8xaEohUpn8=
 github.com/timakin/bodyclose v0.0.0-20200424151742-cb6215831a94 h1:ig99OeTyDwQWhPe2iw9lwfQVF1KB3Q4fpP3X7/2VBG8=
 github.com/timakin/bodyclose v0.0.0-20200424151742-cb6215831a94/go.mod h1:Qimiffbc6q9tBWlVV6x0P9sat/ao1xEkREYPPj9hphk=
-github.com/tinylib/msgp v1.1.5/go.mod h1:eQsjooMTnV42mHu917E26IogZ2930nFyBQdofk10Udg=
 github.com/tklauser/go-sysconf v0.3.7/go.mod h1:JZIdXh4RmBvZDBZ41ld2bGxRV3n4daiiqA3skYhAoQ4=
 github.com/tklauser/numcpus v0.2.3/go.mod h1:vpEPS/JC+oZGGQ/My/vJnNsvMDQL6PwOqt8dsCw5j+E=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
@@ -929,8 +936,8 @@ github.com/tomarrell/wrapcheck/v2 v2.3.0/go.mod h1:aF5rnkdtqNWP/gC7vPUO5pKsB0Oac
 github.com/tomasen/realip v0.0.0-20180522021738-f0c99a92ddce/go.mod h1:o8v6yHRoik09Xen7gje4m9ERNah1d1PPsVq1VEx9vE4=
 github.com/tommy-muehle/go-mnd/v2 v2.4.0 h1:1t0f8Uiaq+fqKteUR4N9Umr6E99R+lDnLnq7PwX2PPE=
 github.com/tommy-muehle/go-mnd/v2 v2.4.0/go.mod h1:WsUAkMJMYww6l/ufffCD3m+P7LEvr8TnZn9lwVDlgzw=
-github.com/ttacon/chalk v0.0.0-20160626202418-22c06c80ed31/go.mod h1:onvgF043R+lC5RZ8IT9rBXDaEDnpnw/Cl+HFiw+v/7Q=
 github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM=
+github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c/go.mod h1:hzIxponao9Kjc7aWznkXaL4U4TWaDSs8zcsY4Ka08nM=
 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
 github.com/ugorji/go v1.1.7/go.mod h1:kZn38zHttfInRq0xu/PH0az30d+z6vm202qpg1oXVMw=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
@@ -950,6 +957,8 @@ github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV
 github.com/vektra/mockery/v2 v2.9.4 h1:ZjpYWY+YLkDIKrKtFnYPxJax10lktcUapWZtOSg4g7g=
 github.com/vektra/mockery/v2 v2.9.4/go.mod h1:2gU4Cf/f8YyC8oEaSXfCnZBMxMjMl/Ko205rlP0fO90=
 github.com/viki-org/dnscache v0.0.0-20130720023526-c70c1f23c5d8/go.mod h1:dniwbG03GafCjFohMDmz6Zc6oCuiqgH6tGNyXTkHzXE=
+github.com/vishvananda/netlink v1.1.0/go.mod h1:cTgwzPIzzgDAYoQrMm0EdrjRUBkTqKYppBueQtXaqoE=
+github.com/vishvananda/netns v0.0.0-20191106174202-0a2b9b5464df/go.mod h1:JP3t17pCcGlemwknint6hfoeCVQrEMVwxRLRjXpq+BU=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
 github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
@@ -1107,6 +1116,7 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY
 golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
@@ -1115,8 +1125,9 @@ golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT
 golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20210525063256-abc453219eb5/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20210614182718-04defd469f4e/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
-golang.org/x/net v0.0.0-20210917221730-978cfadd31cf h1:R150MpwJIv1MpS0N/pc+NhTM8ajzvlmxlY5OYsrevXQ=
 golang.org/x/net v0.0.0-20210917221730-978cfadd31cf/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211005001312-d4b1ae081e3b h1:SXy8Ld8oKlcogOvUAh0J5Pm5RKzgYBMMxLxt6n5XW50=
+golang.org/x/net v0.0.0-20211005001312-d4b1ae081e3b/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -1163,6 +1174,7 @@ golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1176,8 +1188,10 @@ golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191115151921-52ab43148777/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1202,6 +1216,7 @@ golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -1217,6 +1232,7 @@ golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -1226,8 +1242,9 @@ golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210917161153-d61c044b1678 h1:J27LZFQBFoihqXoegpscI10HpjZ7B5WQLLKL2FZXQKw=
 golang.org/x/sys v0.0.0-20210917161153-d61c044b1678/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20211004093028-2c5d950f24ef h1:fPxZ3Umkct3LZ8gK9nbk+DWDJ9fstZa2grBn+lWVKPs=
+golang.org/x/sys v0.0.0-20211004093028-2c5d950f24ef/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
@@ -1328,7 +1345,6 @@ golang.org/x/tools v0.0.0-20200831203904-5a2aa26beb65/go.mod h1:Cj7w3i3Rnn0Xh82u
 golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
 golang.org/x/tools v0.0.0-20201001104356-43ebab892c4c/go.mod h1:z6u4i615ZeAfBE4XtMziQW1fSVJXACjjbWkB/mvPzlU=
 golang.org/x/tools v0.0.0-20201002184944-ecd9fd270d5d/go.mod h1:z6u4i615ZeAfBE4XtMziQW1fSVJXACjjbWkB/mvPzlU=
-golang.org/x/tools v0.0.0-20201022035929-9cf592e881e9/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20201023174141-c8cfbd0f21e6/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20201028025901-8cd080b735b3/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
 golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=

From 5bf30bb0491f28b0377657df5ead0c88d8384a50 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Wed, 6 Oct 2021 15:17:44 -0400
Subject: [PATCH 27/57] p2p: cleanup transport interface (#7071)

This is another batch of things to cleanup in the legacy P2P system.
---
 CHANGELOG_PENDING.md                          |   2 +-
 .../commands/reset_priv_validator.go          |  17 +--
 cmd/tendermint/commands/run_node.go           |   2 -
 cmd/tendermint/commands/testnet.go            |   1 -
 config/config.go                              | 105 ++------------
 config/config_test.go                         |  20 ---
 config/toml.go                                |  50 -------
 internal/p2p/conn/connection.go               | 133 ------------------
 internal/p2p/conn/connection_test.go          |  32 +----
 internal/p2p/conn_set.go                      |  82 -----------
 internal/p2p/mock/peer.go                     |   9 +-
 internal/p2p/mocks/connection.go              |  69 +--------
 internal/p2p/mocks/peer.go                    |  15 --
 internal/p2p/router.go                        |   3 +-
 internal/p2p/shim.go                          |  13 --
 internal/p2p/transport.go                     |  27 +---
 internal/p2p/transport_mconn.go               |  49 ++-----
 internal/p2p/transport_mconn_test.go          |   1 -
 internal/p2p/transport_memory.go              |  40 +-----
 internal/p2p/transport_test.go                |  51 ++-----
 internal/p2p/types.go                         |   1 -
 node/node.go                                  |   4 -
 node/setup.go                                 |  22 +--
 rpc/client/helpers.go                         |   2 +-
 test/e2e/runner/setup.go                      |   1 -
 25 files changed, 52 insertions(+), 699 deletions(-)
 delete mode 100644 internal/p2p/conn_set.go

diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md
index d80e3ae61e..9d7ea96aeb 100644
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -17,7 +17,7 @@ Special thanks to external contributors on this release:
 - P2P Protocol
 
   - [p2p] \#7035 Remove legacy P2P routing implementation and
-    associated configuration (@tychoish)
+    associated configuration options (@tychoish)
 
 - Go API
 
diff --git a/cmd/tendermint/commands/reset_priv_validator.go b/cmd/tendermint/commands/reset_priv_validator.go
index 8745e55d8c..5f3e54700d 100644
--- a/cmd/tendermint/commands/reset_priv_validator.go
+++ b/cmd/tendermint/commands/reset_priv_validator.go
@@ -37,7 +37,7 @@ var ResetPrivValidatorCmd = &cobra.Command{
 // XXX: this is totally unsafe.
 // it's only suitable for testnets.
 func resetAll(cmd *cobra.Command, args []string) error {
-	return ResetAll(config.DBDir(), config.P2P.AddrBookFile(), config.PrivValidator.KeyFile(),
+	return ResetAll(config.DBDir(), config.PrivValidator.KeyFile(),
 		config.PrivValidator.StateFile(), logger)
 }
 
@@ -49,12 +49,7 @@ func resetPrivValidator(cmd *cobra.Command, args []string) error {
 
 // ResetAll removes address book files plus all data, and resets the privValdiator data.
 // Exported so other CLI tools can use it.
-func ResetAll(dbDir, addrBookFile, privValKeyFile, privValStateFile string, logger log.Logger) error {
-	if keepAddrBook {
-		logger.Info("The address book remains intact")
-	} else {
-		removeAddrBook(addrBookFile, logger)
-	}
+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 {
@@ -87,11 +82,3 @@ func resetFilePV(privValKeyFile, privValStateFile string, logger log.Logger) err
 	}
 	return nil
 }
-
-func removeAddrBook(addrBookFile string, logger log.Logger) {
-	if err := os.Remove(addrBookFile); err == nil {
-		logger.Info("Removed existing address book", "file", addrBookFile)
-	} else if !os.IsNotExist(err) {
-		logger.Info("Error removing address book", "file", addrBookFile, "err", err)
-	}
-}
diff --git a/cmd/tendermint/commands/run_node.go b/cmd/tendermint/commands/run_node.go
index 1e310f5eb9..0c6d3271ec 100644
--- a/cmd/tendermint/commands/run_node.go
+++ b/cmd/tendermint/commands/run_node.go
@@ -84,8 +84,6 @@ func AddNodeFlags(cmd *cobra.Command) {
 		"node listen address. (0.0.0.0:0 means any interface, any port)")
 	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().String("p2p.unconditional-peer-ids",
-		config.P2P.UnconditionalPeerIDs, "comma-delimited IDs of unconditional 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")
diff --git a/cmd/tendermint/commands/testnet.go b/cmd/tendermint/commands/testnet.go
index a7307b38fb..ef46f54280 100644
--- a/cmd/tendermint/commands/testnet.go
+++ b/cmd/tendermint/commands/testnet.go
@@ -226,7 +226,6 @@ func testnetFiles(cmd *cobra.Command, args []string) error {
 	for i := 0; i < nValidators+nNonValidators; i++ {
 		nodeDir := filepath.Join(outputDir, fmt.Sprintf("%s%d", nodeDirPrefix, i))
 		config.SetRoot(nodeDir)
-		config.P2P.AddrBookStrict = false
 		config.P2P.AllowDuplicateIP = true
 		if populatePersistentPeers {
 			persistentPeersWithoutSelf := make([]string, 0)
diff --git a/config/config.go b/config/config.go
index 349e5a6f77..0e204b6e68 100644
--- a/config/config.go
+++ b/config/config.go
@@ -53,16 +53,14 @@ var (
 	defaultPrivValKeyName   = "priv_validator_key.json"
 	defaultPrivValStateName = "priv_validator_state.json"
 
-	defaultNodeKeyName  = "node_key.json"
-	defaultAddrBookName = "addrbook.json"
+	defaultNodeKeyName = "node_key.json"
 
 	defaultConfigFilePath   = filepath.Join(defaultConfigDir, defaultConfigFileName)
 	defaultGenesisJSONPath  = filepath.Join(defaultConfigDir, defaultGenesisJSONName)
 	defaultPrivValKeyPath   = filepath.Join(defaultConfigDir, defaultPrivValKeyName)
 	defaultPrivValStatePath = filepath.Join(defaultDataDir, defaultPrivValStateName)
 
-	defaultNodeKeyPath  = filepath.Join(defaultConfigDir, defaultNodeKeyName)
-	defaultAddrBookPath = filepath.Join(defaultConfigDir, defaultAddrBookName)
+	defaultNodeKeyPath = filepath.Join(defaultConfigDir, defaultNodeKeyName)
 )
 
 // Config defines the top level configuration for a Tendermint node
@@ -141,9 +139,6 @@ func (cfg *Config) ValidateBasic() error {
 	if err := cfg.RPC.ValidateBasic(); err != nil {
 		return fmt.Errorf("error in [rpc] section: %w", err)
 	}
-	if err := cfg.P2P.ValidateBasic(); err != nil {
-		return fmt.Errorf("error in [p2p] section: %w", err)
-	}
 	if err := cfg.Mempool.ValidateBasic(); err != nil {
 		return fmt.Errorf("error in [mempool] section: %w", err)
 	}
@@ -646,25 +641,6 @@ type P2PConfig struct { //nolint: maligned
 	// UPNP port forwarding
 	UPNP bool `mapstructure:"upnp"`
 
-	// Path to address book
-	AddrBook string `mapstructure:"addr-book-file"`
-
-	// Set true for strict address routability rules
-	// Set false for private or local networks
-	AddrBookStrict bool `mapstructure:"addr-book-strict"`
-
-	// Maximum number of inbound peers
-	//
-	// TODO: Remove once p2p refactor is complete in favor of MaxConnections.
-	// ref: https://github.com/tendermint/tendermint/issues/5670
-	MaxNumInboundPeers int `mapstructure:"max-num-inbound-peers"`
-
-	// Maximum number of outbound peers to connect to, excluding persistent peers.
-	//
-	// TODO: Remove once p2p refactor is complete in favor of MaxConnections.
-	// ref: https://github.com/tendermint/tendermint/issues/5670
-	MaxNumOutboundPeers int `mapstructure:"max-num-outbound-peers"`
-
 	// MaxConnections defines the maximum number of connected peers (inbound and
 	// outbound).
 	MaxConnections uint16 `mapstructure:"max-connections"`
@@ -673,24 +649,6 @@ type P2PConfig struct { //nolint: maligned
 	// attempts per IP address.
 	MaxIncomingConnectionAttempts uint `mapstructure:"max-incoming-connection-attempts"`
 
-	// List of node IDs, to which a connection will be (re)established ignoring any existing limits
-	UnconditionalPeerIDs string `mapstructure:"unconditional-peer-ids"`
-
-	// Maximum pause when redialing a persistent peer (if zero, exponential backoff is used)
-	PersistentPeersMaxDialPeriod time.Duration `mapstructure:"persistent-peers-max-dial-period"`
-
-	// Time to wait before flushing messages out on the connection
-	FlushThrottleTimeout time.Duration `mapstructure:"flush-throttle-timeout"`
-
-	// Maximum size of a message packet payload, in bytes
-	MaxPacketMsgPayloadSize int `mapstructure:"max-packet-msg-payload-size"`
-
-	// Rate at which packets can be sent, in bytes/second
-	SendRate int64 `mapstructure:"send-rate"`
-
-	// Rate at which packets can be received, in bytes/second
-	RecvRate int64 `mapstructure:"recv-rate"`
-
 	// Set true to enable the peer-exchange reactor
 	PexReactor bool `mapstructure:"pex"`
 
@@ -721,28 +679,14 @@ func DefaultP2PConfig() *P2PConfig {
 		ListenAddress:                 "tcp://0.0.0.0:26656",
 		ExternalAddress:               "",
 		UPNP:                          false,
-		AddrBook:                      defaultAddrBookPath,
-		AddrBookStrict:                true,
-		MaxNumInboundPeers:            40,
-		MaxNumOutboundPeers:           10,
 		MaxConnections:                64,
 		MaxIncomingConnectionAttempts: 100,
-		PersistentPeersMaxDialPeriod:  0 * time.Second,
-		FlushThrottleTimeout:          100 * time.Millisecond,
-		// The MTU (Maximum Transmission Unit) for Ethernet is 1500 bytes.
-		// The IP header and the TCP header take up 20 bytes each at least (unless
-		// optional header fields are used) and thus the max for (non-Jumbo frame)
-		// Ethernet is 1500 - 20 -20 = 1460
-		// Source: https://stackoverflow.com/a/3074427/820520
-		MaxPacketMsgPayloadSize: 1400,
-		SendRate:                5120000, // 5 mB/s
-		RecvRate:                5120000, // 5 mB/s
-		PexReactor:              true,
-		AllowDuplicateIP:        false,
-		HandshakeTimeout:        20 * time.Second,
-		DialTimeout:             3 * time.Second,
-		TestDialFail:            false,
-		QueueType:               "priority",
+		PexReactor:                    true,
+		AllowDuplicateIP:              false,
+		HandshakeTimeout:              20 * time.Second,
+		DialTimeout:                   3 * time.Second,
+		TestDialFail:                  false,
+		QueueType:                     "priority",
 	}
 }
 
@@ -750,43 +694,10 @@ func DefaultP2PConfig() *P2PConfig {
 func TestP2PConfig() *P2PConfig {
 	cfg := DefaultP2PConfig()
 	cfg.ListenAddress = "tcp://127.0.0.1:36656"
-	cfg.FlushThrottleTimeout = 10 * time.Millisecond
 	cfg.AllowDuplicateIP = true
 	return cfg
 }
 
-// AddrBookFile returns the full path to the address book
-func (cfg *P2PConfig) AddrBookFile() string {
-	return rootify(cfg.AddrBook, cfg.RootDir)
-}
-
-// ValidateBasic performs basic validation (checking param bounds, etc.) and
-// returns an error if any check fails.
-func (cfg *P2PConfig) ValidateBasic() error {
-	if cfg.MaxNumInboundPeers < 0 {
-		return errors.New("max-num-inbound-peers can't be negative")
-	}
-	if cfg.MaxNumOutboundPeers < 0 {
-		return errors.New("max-num-outbound-peers can't be negative")
-	}
-	if cfg.FlushThrottleTimeout < 0 {
-		return errors.New("flush-throttle-timeout can't be negative")
-	}
-	if cfg.PersistentPeersMaxDialPeriod < 0 {
-		return errors.New("persistent-peers-max-dial-period can't be negative")
-	}
-	if cfg.MaxPacketMsgPayloadSize < 0 {
-		return errors.New("max-packet-msg-payload-size can't be negative")
-	}
-	if cfg.SendRate < 0 {
-		return errors.New("send-rate can't be negative")
-	}
-	if cfg.RecvRate < 0 {
-		return errors.New("recv-rate can't be negative")
-	}
-	return nil
-}
-
 //-----------------------------------------------------------------------------
 // MempoolConfig
 
diff --git a/config/config_test.go b/config/config_test.go
index 79d6279102..db0fb59673 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -82,26 +82,6 @@ func TestRPCConfigValidateBasic(t *testing.T) {
 	}
 }
 
-func TestP2PConfigValidateBasic(t *testing.T) {
-	cfg := TestP2PConfig()
-	assert.NoError(t, cfg.ValidateBasic())
-
-	fieldsToTest := []string{
-		"MaxNumInboundPeers",
-		"MaxNumOutboundPeers",
-		"FlushThrottleTimeout",
-		"MaxPacketMsgPayloadSize",
-		"SendRate",
-		"RecvRate",
-	}
-
-	for _, fieldName := range fieldsToTest {
-		reflect.ValueOf(cfg).Elem().FieldByName(fieldName).SetInt(-1)
-		assert.Error(t, cfg.ValidateBasic())
-		reflect.ValueOf(cfg).Elem().FieldByName(fieldName).SetInt(0)
-	}
-}
-
 func TestMempoolConfigValidateBasic(t *testing.T) {
 	cfg := TestMempoolConfig()
 	assert.NoError(t, cfg.ValidateBasic())
diff --git a/config/toml.go b/config/toml.go
index ee4c30004d..1159640fb1 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -296,62 +296,12 @@ persistent-peers = "{{ .P2P.PersistentPeers }}"
 # UPNP port forwarding
 upnp = {{ .P2P.UPNP }}
 
-# Path to address book
-# TODO: Remove once p2p refactor is complete in favor of peer store.
-addr-book-file = "{{ js .P2P.AddrBook }}"
-
-# Set true for strict address routability rules
-# Set false for private or local networks
-addr-book-strict = {{ .P2P.AddrBookStrict }}
-
-# Maximum number of inbound peers
-#
-# TODO: Remove once p2p refactor is complete in favor of MaxConnections.
-# ref: https://github.com/tendermint/tendermint/issues/5670
-max-num-inbound-peers = {{ .P2P.MaxNumInboundPeers }}
-
-# Maximum number of outbound peers to connect to, excluding persistent peers
-#
-# TODO: Remove once p2p refactor is complete in favor of MaxConnections.
-# ref: https://github.com/tendermint/tendermint/issues/5670
-max-num-outbound-peers = {{ .P2P.MaxNumOutboundPeers }}
-
 # Maximum number of connections (inbound and outbound).
 max-connections = {{ .P2P.MaxConnections }}
 
 # Rate limits the number of incoming connection attempts per IP address.
 max-incoming-connection-attempts = {{ .P2P.MaxIncomingConnectionAttempts }}
 
-# List of node IDs, to which a connection will be (re)established ignoring any existing limits
-# TODO: Remove once p2p refactor is complete.
-# ref: https://github.com/tendermint/tendermint/issues/5670
-unconditional-peer-ids = "{{ .P2P.UnconditionalPeerIDs }}"
-
-# Maximum pause when redialing a persistent peer (if zero, exponential backoff is used)
-# TODO: Remove once p2p refactor is complete
-# ref: https:#github.com/tendermint/tendermint/issues/5670
-persistent-peers-max-dial-period = "{{ .P2P.PersistentPeersMaxDialPeriod }}"
-
-# Time to wait before flushing messages out on the connection
-# TODO: Remove once p2p refactor is complete
-# ref: https:#github.com/tendermint/tendermint/issues/5670
-flush-throttle-timeout = "{{ .P2P.FlushThrottleTimeout }}"
-
-# Maximum size of a message packet payload, in bytes
-# TODO: Remove once p2p refactor is complete
-# ref: https:#github.com/tendermint/tendermint/issues/5670
-max-packet-msg-payload-size = {{ .P2P.MaxPacketMsgPayloadSize }}
-
-# Rate at which packets can be sent, in bytes/second
-# TODO: Remove once p2p refactor is complete
-# ref: https:#github.com/tendermint/tendermint/issues/5670
-send-rate = {{ .P2P.SendRate }}
-
-# Rate at which packets can be received, in bytes/second
-# TODO: Remove once p2p refactor is complete
-# ref: https:#github.com/tendermint/tendermint/issues/5670
-recv-rate = {{ .P2P.RecvRate }}
-
 # Set true to enable the peer-exchange reactor
 pex = {{ .P2P.PexReactor }}
 
diff --git a/internal/p2p/conn/connection.go b/internal/p2p/conn/connection.go
index 339ad74697..0ab7b7546b 100644
--- a/internal/p2p/conn/connection.go
+++ b/internal/p2p/conn/connection.go
@@ -64,15 +64,11 @@ initialization of the connection.
 
 There are two methods for sending messages:
 	func (m MConnection) Send(chID byte, msgBytes []byte) bool {}
-	func (m MConnection) TrySend(chID byte, msgBytes []byte}) bool {}
 
 `Send(chID, msgBytes)` is a blocking call that waits until `msg` is
 successfully queued for the channel with the given id byte `chID`, or until the
 request times out.  The message `msg` is serialized using Protobuf.
 
-`TrySend(chID, msgBytes)` is a nonblocking call that returns false if the
-channel's queue is full.
-
 Inbound message bytes are handled with an onReceive callback function.
 */
 type MConnection struct {
@@ -265,43 +261,6 @@ func (c *MConnection) stopServices() (alreadyStopped bool) {
 	return false
 }
 
-// FlushStop replicates the logic of OnStop.
-// It additionally ensures that all successful
-// .Send() calls will get flushed before closing
-// the connection.
-func (c *MConnection) FlushStop() {
-	if c.stopServices() {
-		return
-	}
-
-	// this block is unique to FlushStop
-	{
-		// wait until the sendRoutine exits
-		// so we dont race on calling sendSomePacketMsgs
-		<-c.doneSendRoutine
-
-		// Send and flush all pending msgs.
-		// Since sendRoutine has exited, we can call this
-		// safely
-		eof := c.sendSomePacketMsgs()
-		for !eof {
-			eof = c.sendSomePacketMsgs()
-		}
-		c.flush()
-
-		// Now we can close the connection
-	}
-
-	c.conn.Close()
-
-	// We can't close pong safely here because
-	// recvRoutine may write to it after we've stopped.
-	// Though it doesn't need to get closed at all,
-	// we close it @ recvRoutine.
-
-	// c.Stop()
-}
-
 // OnStop implements BaseService
 func (c *MConnection) OnStop() {
 	if c.stopServices() {
@@ -375,49 +334,6 @@ func (c *MConnection) Send(chID byte, msgBytes []byte) bool {
 	return success
 }
 
-// Queues a message to be sent to channel.
-// Nonblocking, returns true if successful.
-func (c *MConnection) TrySend(chID byte, msgBytes []byte) bool {
-	if !c.IsRunning() {
-		return false
-	}
-
-	c.Logger.Debug("TrySend", "channel", chID, "conn", c, "msgBytes", msgBytes)
-
-	// Send message to channel.
-	channel, ok := c.channelsIdx[chID]
-	if !ok {
-		c.Logger.Error(fmt.Sprintf("Cannot send bytes, unknown channel %X", chID))
-		return false
-	}
-
-	ok = channel.trySendBytes(msgBytes)
-	if ok {
-		// Wake up sendRoutine if necessary
-		select {
-		case c.send <- struct{}{}:
-		default:
-		}
-	}
-
-	return ok
-}
-
-// CanSend returns true if you can send more data onto the chID, false
-// otherwise. Use only as a heuristic.
-func (c *MConnection) CanSend(chID byte) bool {
-	if !c.IsRunning() {
-		return false
-	}
-
-	channel, ok := c.channelsIdx[chID]
-	if !ok {
-		c.Logger.Error(fmt.Sprintf("Unknown channel %X", chID))
-		return false
-	}
-	return channel.canSend()
-}
-
 // sendRoutine polls for packets to send from channels.
 func (c *MConnection) sendRoutine() {
 	defer c._recover()
@@ -682,13 +598,6 @@ func (c *MConnection) maxPacketMsgSize() int {
 	return len(bz)
 }
 
-type ConnectionStatus struct {
-	Duration    time.Duration
-	SendMonitor flow.Status
-	RecvMonitor flow.Status
-	Channels    []ChannelStatus
-}
-
 type ChannelStatus struct {
 	ID                byte
 	SendQueueCapacity int
@@ -697,24 +606,6 @@ type ChannelStatus struct {
 	RecentlySent      int64
 }
 
-func (c *MConnection) Status() ConnectionStatus {
-	var status ConnectionStatus
-	status.Duration = time.Since(c.created)
-	status.SendMonitor = c.sendMonitor.Status()
-	status.RecvMonitor = c.recvMonitor.Status()
-	status.Channels = make([]ChannelStatus, len(c.channels))
-	for i, channel := range c.channels {
-		status.Channels[i] = ChannelStatus{
-			ID:                channel.desc.ID,
-			SendQueueCapacity: cap(channel.sendQueue),
-			SendQueueSize:     int(atomic.LoadInt32(&channel.sendQueueSize)),
-			Priority:          channel.desc.Priority,
-			RecentlySent:      atomic.LoadInt64(&channel.recentlySent),
-		}
-	}
-	return status
-}
-
 //-----------------------------------------------------------------------------
 
 type ChannelDescriptor struct {
@@ -800,30 +691,6 @@ func (ch *Channel) sendBytes(bytes []byte) bool {
 	}
 }
 
-// Queues message to send to this channel.
-// Nonblocking, returns true if successful.
-// Goroutine-safe
-func (ch *Channel) trySendBytes(bytes []byte) bool {
-	select {
-	case ch.sendQueue <- bytes:
-		atomic.AddInt32(&ch.sendQueueSize, 1)
-		return true
-	default:
-		return false
-	}
-}
-
-// Goroutine-safe
-func (ch *Channel) loadSendQueueSize() (size int) {
-	return int(atomic.LoadInt32(&ch.sendQueueSize))
-}
-
-// Goroutine-safe
-// Use only as a heuristic.
-func (ch *Channel) canSend() bool {
-	return ch.loadSendQueueSize() < defaultSendQueueCapacity
-}
-
 // Returns true if any PacketMsgs are pending to be sent.
 // Call before calling nextPacketMsg()
 // Goroutine-safe
diff --git a/internal/p2p/conn/connection_test.go b/internal/p2p/conn/connection_test.go
index 6d009f85cf..6a9c0988f5 100644
--- a/internal/p2p/conn/connection_test.go
+++ b/internal/p2p/conn/connection_test.go
@@ -69,9 +69,6 @@ func TestMConnectionSendFlushStop(t *testing.T) {
 		errCh <- err
 	}()
 
-	// stop the conn - it should flush all conns
-	clientConn.FlushStop()
-
 	timer := time.NewTimer(3 * time.Second)
 	select {
 	case <-errCh:
@@ -97,16 +94,14 @@ func TestMConnectionSend(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	assert.True(t, mconn.CanSend(0x01))
 
 	msg = []byte("Spider-Man")
-	assert.True(t, mconn.TrySend(0x01, msg))
+	assert.True(t, mconn.Send(0x01, msg))
 	_, err = server.Read(make([]byte, len(msg)))
 	if err != nil {
 		t.Error(err)
 	}
 
-	assert.False(t, mconn.CanSend(0x05), "CanSend should return false because channel is unknown")
 	assert.False(t, mconn.Send(0x05, []byte("Absorbing Man")), "Send should return false because channel is unknown")
 }
 
@@ -145,20 +140,6 @@ func TestMConnectionReceive(t *testing.T) {
 	}
 }
 
-func TestMConnectionStatus(t *testing.T) {
-	server, client := NetPipe()
-	t.Cleanup(closeAll(t, client, server))
-
-	mconn := createTestMConnection(client)
-	err := mconn.Start()
-	require.Nil(t, err)
-	t.Cleanup(stopAll(t, mconn))
-
-	status := mconn.Status()
-	assert.NotNil(t, status)
-	assert.Zero(t, status.Channels[0].SendQueueSize)
-}
-
 func TestMConnectionPongTimeoutResultsInError(t *testing.T) {
 	server, client := net.Pipe()
 	t.Cleanup(closeAll(t, client, server))
@@ -514,18 +495,15 @@ func TestMConnectionTrySend(t *testing.T) {
 
 	msg := []byte("Semicolon-Woman")
 	resultCh := make(chan string, 2)
-	assert.True(t, mconn.TrySend(0x01, msg))
+	assert.True(t, mconn.Send(0x01, msg))
 	_, err = server.Read(make([]byte, len(msg)))
 	require.NoError(t, err)
-	assert.True(t, mconn.CanSend(0x01))
-	assert.True(t, mconn.TrySend(0x01, msg))
-	assert.False(t, mconn.CanSend(0x01))
+	assert.True(t, mconn.Send(0x01, msg))
 	go func() {
-		mconn.TrySend(0x01, msg)
+		mconn.Send(0x01, msg)
 		resultCh <- "TrySend"
 	}()
-	assert.False(t, mconn.CanSend(0x01))
-	assert.False(t, mconn.TrySend(0x01, msg))
+	assert.False(t, mconn.Send(0x01, msg))
 	assert.Equal(t, "TrySend", <-resultCh)
 }
 
diff --git a/internal/p2p/conn_set.go b/internal/p2p/conn_set.go
deleted file mode 100644
index 987d9f968a..0000000000
--- a/internal/p2p/conn_set.go
+++ /dev/null
@@ -1,82 +0,0 @@
-package p2p
-
-import (
-	"net"
-
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-)
-
-// ConnSet is a lookup table for connections and all their ips.
-type ConnSet interface {
-	Has(net.Conn) bool
-	HasIP(net.IP) bool
-	Set(net.Conn, []net.IP)
-	Remove(net.Conn)
-	RemoveAddr(net.Addr)
-}
-
-type connSetItem struct {
-	conn net.Conn
-	ips  []net.IP
-}
-
-type connSet struct {
-	tmsync.RWMutex
-
-	conns map[string]connSetItem
-}
-
-// NewConnSet returns a ConnSet implementation.
-func NewConnSet() ConnSet {
-	return &connSet{
-		conns: map[string]connSetItem{},
-	}
-}
-
-func (cs *connSet) Has(c net.Conn) bool {
-	cs.RLock()
-	defer cs.RUnlock()
-
-	_, ok := cs.conns[c.RemoteAddr().String()]
-
-	return ok
-}
-
-func (cs *connSet) HasIP(ip net.IP) bool {
-	cs.RLock()
-	defer cs.RUnlock()
-
-	for _, c := range cs.conns {
-		for _, known := range c.ips {
-			if known.Equal(ip) {
-				return true
-			}
-		}
-	}
-
-	return false
-}
-
-func (cs *connSet) Remove(c net.Conn) {
-	cs.Lock()
-	defer cs.Unlock()
-
-	delete(cs.conns, c.RemoteAddr().String())
-}
-
-func (cs *connSet) RemoveAddr(addr net.Addr) {
-	cs.Lock()
-	defer cs.Unlock()
-
-	delete(cs.conns, addr.String())
-}
-
-func (cs *connSet) Set(c net.Conn, ips []net.IP) {
-	cs.Lock()
-	defer cs.Unlock()
-
-	cs.conns[c.RemoteAddr().String()] = connSetItem{
-		conn: c,
-		ips:  ips,
-	}
-}
diff --git a/internal/p2p/mock/peer.go b/internal/p2p/mock/peer.go
index cede517685..366f1d7fdd 100644
--- a/internal/p2p/mock/peer.go
+++ b/internal/p2p/mock/peer.go
@@ -4,7 +4,6 @@ import (
 	"net"
 
 	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
 	"github.com/tendermint/tendermint/libs/service"
 	"github.com/tendermint/tendermint/types"
 )
@@ -51,10 +50,10 @@ func (mp *Peer) NodeInfo() types.NodeInfo {
 		ListenAddr: mp.addr.DialString(),
 	}
 }
-func (mp *Peer) Status() conn.ConnectionStatus { return conn.ConnectionStatus{} }
-func (mp *Peer) ID() types.NodeID              { return mp.id }
-func (mp *Peer) IsOutbound() bool              { return mp.Outbound }
-func (mp *Peer) IsPersistent() bool            { return mp.Persistent }
+
+func (mp *Peer) ID() types.NodeID   { return mp.id }
+func (mp *Peer) IsOutbound() bool   { return mp.Outbound }
+func (mp *Peer) IsPersistent() bool { return mp.Persistent }
 func (mp *Peer) Get(key string) interface{} {
 	if value, ok := mp.kv[key]; ok {
 		return value
diff --git a/internal/p2p/mocks/connection.go b/internal/p2p/mocks/connection.go
index 6c61741172..03f7b5b335 100644
--- a/internal/p2p/mocks/connection.go
+++ b/internal/p2p/mocks/connection.go
@@ -5,11 +5,8 @@ package mocks
 import (
 	context "context"
 
-	conn "github.com/tendermint/tendermint/internal/p2p/conn"
-
-	crypto "github.com/tendermint/tendermint/crypto"
-
 	mock "github.com/stretchr/testify/mock"
+	crypto "github.com/tendermint/tendermint/crypto"
 
 	p2p "github.com/tendermint/tendermint/internal/p2p"
 
@@ -35,20 +32,6 @@ func (_m *Connection) Close() error {
 	return r0
 }
 
-// FlushClose provides a mock function with given fields:
-func (_m *Connection) FlushClose() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
 // Handshake provides a mock function with given fields: _a0, _a1, _a2
 func (_m *Connection) Handshake(_a0 context.Context, _a1 types.NodeInfo, _a2 crypto.PrivKey) (types.NodeInfo, crypto.PubKey, error) {
 	ret := _m.Called(_a0, _a1, _a2)
@@ -138,35 +121,14 @@ func (_m *Connection) RemoteEndpoint() p2p.Endpoint {
 }
 
 // SendMessage provides a mock function with given fields: _a0, _a1
-func (_m *Connection) SendMessage(_a0 p2p.ChannelID, _a1 []byte) (bool, error) {
+func (_m *Connection) SendMessage(_a0 p2p.ChannelID, _a1 []byte) error {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(p2p.ChannelID, []byte) bool); ok {
+	var r0 error
+	if rf, ok := ret.Get(0).(func(p2p.ChannelID, []byte) error); ok {
 		r0 = rf(_a0, _a1)
 	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(p2p.ChannelID, []byte) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
-
-// Status provides a mock function with given fields:
-func (_m *Connection) Status() conn.ConnectionStatus {
-	ret := _m.Called()
-
-	var r0 conn.ConnectionStatus
-	if rf, ok := ret.Get(0).(func() conn.ConnectionStatus); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(conn.ConnectionStatus)
+		r0 = ret.Error(0)
 	}
 
 	return r0
@@ -185,24 +147,3 @@ func (_m *Connection) String() string {
 
 	return r0
 }
-
-// TrySendMessage provides a mock function with given fields: _a0, _a1
-func (_m *Connection) TrySendMessage(_a0 p2p.ChannelID, _a1 []byte) (bool, error) {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(p2p.ChannelID, []byte) bool); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	var r1 error
-	if rf, ok := ret.Get(1).(func(p2p.ChannelID, []byte) error); ok {
-		r1 = rf(_a0, _a1)
-	} else {
-		r1 = ret.Error(1)
-	}
-
-	return r0, r1
-}
diff --git a/internal/p2p/mocks/peer.go b/internal/p2p/mocks/peer.go
index b905c1156b..3e5d20325a 100644
--- a/internal/p2p/mocks/peer.go
+++ b/internal/p2p/mocks/peer.go
@@ -3,7 +3,6 @@
 package mocks
 
 import (
-	conn "github.com/tendermint/tendermint/internal/p2p/conn"
 	log "github.com/tendermint/tendermint/libs/log"
 
 	mock "github.com/stretchr/testify/mock"
@@ -272,20 +271,6 @@ func (_m *Peer) Start() error {
 	return r0
 }
 
-// Status provides a mock function with given fields:
-func (_m *Peer) Status() conn.ConnectionStatus {
-	ret := _m.Called()
-
-	var r0 conn.ConnectionStatus
-	if rf, ok := ret.Get(0).(func() conn.ConnectionStatus); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(conn.ConnectionStatus)
-	}
-
-	return r0
-}
-
 // Stop provides a mock function with given fields:
 func (_m *Peer) Stop() error {
 	ret := _m.Called()
diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index ef1eef5644..ed61194316 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -960,8 +960,7 @@ func (r *Router) sendPeer(peerID types.NodeID, conn Connection, peerQueue queue)
 				continue
 			}
 
-			_, err = conn.SendMessage(envelope.channelID, bz)
-			if err != nil {
+			if err = conn.SendMessage(envelope.channelID, bz); err != nil {
 				return err
 			}
 
diff --git a/internal/p2p/shim.go b/internal/p2p/shim.go
index c9cdc27568..9f82bc11aa 100644
--- a/internal/p2p/shim.go
+++ b/internal/p2p/shim.go
@@ -4,8 +4,6 @@ import (
 	"sort"
 
 	"github.com/gogo/protobuf/proto"
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
 	"github.com/tendermint/tendermint/libs/log"
 )
 
@@ -74,17 +72,6 @@ func NewChannelShim(cds *ChannelDescriptorShim, buf uint) *ChannelShim {
 	}
 }
 
-// MConnConfig returns an MConnConfig based on the defaults, with fields updated
-// from the P2PConfig.
-func MConnConfig(cfg *config.P2PConfig) conn.MConnConfig {
-	mConfig := conn.DefaultMConnConfig()
-	mConfig.FlushThrottle = cfg.FlushThrottleTimeout
-	mConfig.SendRate = cfg.SendRate
-	mConfig.RecvRate = cfg.RecvRate
-	mConfig.MaxPacketMsgPayloadSize = cfg.MaxPacketMsgPayloadSize
-	return mConfig
-}
-
 // GetChannels implements the legacy Reactor interface for getting a slice of all
 // the supported ChannelDescriptors.
 func (rs *ReactorShim) GetChannels() []*ChannelDescriptor {
diff --git a/internal/p2p/transport.go b/internal/p2p/transport.go
index 0b2311fa3f..8440889d40 100644
--- a/internal/p2p/transport.go
+++ b/internal/p2p/transport.go
@@ -7,7 +7,6 @@ import (
 	"net"
 
 	"github.com/tendermint/tendermint/crypto"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -82,19 +81,7 @@ type Connection interface {
 	ReceiveMessage() (ChannelID, []byte, error)
 
 	// SendMessage sends a message on the connection. Returns io.EOF if closed.
-	//
-	// FIXME: For compatibility with the legacy P2P stack, it returns an
-	// additional boolean false if the message timed out waiting to be accepted
-	// into the send buffer. This should be removed.
-	SendMessage(ChannelID, []byte) (bool, error)
-
-	// TrySendMessage is a non-blocking version of SendMessage that returns
-	// immediately if the message buffer is full. It returns true if the message
-	// was accepted.
-	//
-	// FIXME: This method is here for backwards-compatibility with the legacy
-	// P2P stack and should be removed.
-	TrySendMessage(ChannelID, []byte) (bool, error)
+	SendMessage(ChannelID, []byte) error
 
 	// LocalEndpoint returns the local endpoint for the connection.
 	LocalEndpoint() Endpoint
@@ -105,18 +92,6 @@ type Connection interface {
 	// Close closes the connection.
 	Close() error
 
-	// FlushClose flushes all pending sends and then closes the connection.
-	//
-	// FIXME: This only exists for backwards-compatibility with the current
-	// MConnection implementation. There should really be a separate Flush()
-	// method, but there is no easy way to synchronously flush pending data with
-	// the current MConnection code.
-	FlushClose() error
-
-	// Status returns the current connection status.
-	// FIXME: Only here for compatibility with the current Peer code.
-	Status() conn.ConnectionStatus
-
 	// Stringer is used to display the connection, e.g. in logs.
 	//
 	// Without this, the logger may use reflection to access and display
diff --git a/internal/p2p/transport_mconn.go b/internal/p2p/transport_mconn.go
index eca261476c..de643bdb96 100644
--- a/internal/p2p/transport_mconn.go
+++ b/internal/p2p/transport_mconn.go
@@ -377,32 +377,21 @@ func (c *mConnConnection) String() string {
 }
 
 // SendMessage implements Connection.
-func (c *mConnConnection) SendMessage(chID ChannelID, msg []byte) (bool, error) {
+func (c *mConnConnection) SendMessage(chID ChannelID, msg []byte) error {
 	if chID > math.MaxUint8 {
-		return false, fmt.Errorf("MConnection only supports 1-byte channel IDs (got %v)", chID)
+		return fmt.Errorf("MConnection only supports 1-byte channel IDs (got %v)", chID)
 	}
 	select {
 	case err := <-c.errorCh:
-		return false, err
+		return err
 	case <-c.closeCh:
-		return false, io.EOF
+		return io.EOF
 	default:
-		return c.mconn.Send(byte(chID), msg), nil
-	}
-}
+		if ok := c.mconn.Send(byte(chID), msg); !ok {
+			return errors.New("sending message timed out")
+		}
 
-// TrySendMessage implements Connection.
-func (c *mConnConnection) TrySendMessage(chID ChannelID, msg []byte) (bool, error) {
-	if chID > math.MaxUint8 {
-		return false, fmt.Errorf("MConnection only supports 1-byte channel IDs (got %v)", chID)
-	}
-	select {
-	case err := <-c.errorCh:
-		return false, err
-	case <-c.closeCh:
-		return false, io.EOF
-	default:
-		return c.mconn.TrySend(byte(chID), msg), nil
+		return nil
 	}
 }
 
@@ -442,14 +431,6 @@ func (c *mConnConnection) RemoteEndpoint() Endpoint {
 	return endpoint
 }
 
-// Status implements Connection.
-func (c *mConnConnection) Status() conn.ConnectionStatus {
-	if c.mconn == nil {
-		return conn.ConnectionStatus{}
-	}
-	return c.mconn.Status()
-}
-
 // Close implements Connection.
 func (c *mConnConnection) Close() error {
 	var err error
@@ -463,17 +444,3 @@ func (c *mConnConnection) Close() error {
 	})
 	return err
 }
-
-// FlushClose implements Connection.
-func (c *mConnConnection) FlushClose() error {
-	var err error
-	c.closeOnce.Do(func() {
-		if c.mconn != nil && c.mconn.IsRunning() {
-			c.mconn.FlushStop()
-		} else {
-			err = c.conn.Close()
-		}
-		close(c.closeCh)
-	})
-	return err
-}
diff --git a/internal/p2p/transport_mconn_test.go b/internal/p2p/transport_mconn_test.go
index 06cd93c0a0..f4d7198edf 100644
--- a/internal/p2p/transport_mconn_test.go
+++ b/internal/p2p/transport_mconn_test.go
@@ -195,7 +195,6 @@ func TestMConnTransport_Listen(t *testing.T) {
 			_ = conn.Close()
 			<-dialedChan
 
-			time.Sleep(time.Minute)
 			// closing the connection should not error
 			require.NoError(t, peerConn.Close())
 
diff --git a/internal/p2p/transport_memory.go b/internal/p2p/transport_memory.go
index 09a3872548..853288c59f 100644
--- a/internal/p2p/transport_memory.go
+++ b/internal/p2p/transport_memory.go
@@ -10,7 +10,6 @@ import (
 
 	"github.com/tendermint/tendermint/crypto"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/p2p/conn"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/types"
 )
@@ -262,11 +261,6 @@ func (c *MemoryConnection) RemoteEndpoint() Endpoint {
 	}
 }
 
-// Status implements Connection.
-func (c *MemoryConnection) Status() conn.ConnectionStatus {
-	return conn.ConnectionStatus{}
-}
-
 // Handshake implements Connection.
 func (c *MemoryConnection) Handshake(
 	ctx context.Context,
@@ -316,42 +310,21 @@ func (c *MemoryConnection) ReceiveMessage() (ChannelID, []byte, error) {
 }
 
 // SendMessage implements Connection.
-func (c *MemoryConnection) SendMessage(chID ChannelID, msg []byte) (bool, error) {
-	// Check close first, since channels are buffered. Otherwise, below select
-	// may non-deterministically return non-error even when closed.
-	select {
-	case <-c.closer.Done():
-		return false, io.EOF
-	default:
-	}
-
-	select {
-	case c.sendCh <- memoryMessage{channelID: chID, message: msg}:
-		c.logger.Debug("sent message", "chID", chID, "msg", msg)
-		return true, nil
-	case <-c.closer.Done():
-		return false, io.EOF
-	}
-}
-
-// TrySendMessage implements Connection.
-func (c *MemoryConnection) TrySendMessage(chID ChannelID, msg []byte) (bool, error) {
+func (c *MemoryConnection) SendMessage(chID ChannelID, msg []byte) error {
 	// Check close first, since channels are buffered. Otherwise, below select
 	// may non-deterministically return non-error even when closed.
 	select {
 	case <-c.closer.Done():
-		return false, io.EOF
+		return io.EOF
 	default:
 	}
 
 	select {
 	case c.sendCh <- memoryMessage{channelID: chID, message: msg}:
 		c.logger.Debug("sent message", "chID", chID, "msg", msg)
-		return true, nil
+		return nil
 	case <-c.closer.Done():
-		return false, io.EOF
-	default:
-		return false, nil
+		return io.EOF
 	}
 }
 
@@ -366,8 +339,3 @@ func (c *MemoryConnection) Close() error {
 	}
 	return nil
 }
-
-// FlushClose implements Connection.
-func (c *MemoryConnection) FlushClose() error {
-	return c.Close()
-}
diff --git a/internal/p2p/transport_test.go b/internal/p2p/transport_test.go
index 1b8ab77f5a..cdfb57c70b 100644
--- a/internal/p2p/transport_test.go
+++ b/internal/p2p/transport_test.go
@@ -315,22 +315,16 @@ func TestConnection_FlushClose(t *testing.T) {
 		b := makeTransport(t)
 		ab, _ := dialAcceptHandshake(t, a, b)
 
-		// FIXME: FlushClose should be removed (and replaced by separate Flush
-		// and Close calls if necessary). We can't reliably test it, so we just
-		// make sure it closes both ends and that it's idempotent.
-		err := ab.FlushClose()
+		err := ab.Close()
 		require.NoError(t, err)
 
 		_, _, err = ab.ReceiveMessage()
 		require.Error(t, err)
 		require.Equal(t, io.EOF, err)
 
-		_, err = ab.SendMessage(chID, []byte("closed"))
+		err = ab.SendMessage(chID, []byte("closed"))
 		require.Error(t, err)
 		require.Equal(t, io.EOF, err)
-
-		err = ab.FlushClose()
-		require.NoError(t, err)
 	})
 }
 
@@ -355,9 +349,8 @@ func TestConnection_SendReceive(t *testing.T) {
 		ab, ba := dialAcceptHandshake(t, a, b)
 
 		// Can send and receive a to b.
-		ok, err := ab.SendMessage(chID, []byte("foo"))
+		err := ab.SendMessage(chID, []byte("foo"))
 		require.NoError(t, err)
-		require.True(t, ok)
 
 		ch, msg, err := ba.ReceiveMessage()
 		require.NoError(t, err)
@@ -365,30 +358,20 @@ func TestConnection_SendReceive(t *testing.T) {
 		require.Equal(t, chID, ch)
 
 		// Can send and receive b to a.
-		_, err = ba.SendMessage(chID, []byte("bar"))
+		err = ba.SendMessage(chID, []byte("bar"))
 		require.NoError(t, err)
 
 		_, msg, err = ab.ReceiveMessage()
 		require.NoError(t, err)
 		require.Equal(t, []byte("bar"), msg)
 
-		// TrySendMessage also works.
-		ok, err = ba.TrySendMessage(chID, []byte("try"))
-		require.NoError(t, err)
-		require.True(t, ok)
-
-		ch, msg, err = ab.ReceiveMessage()
-		require.NoError(t, err)
-		require.Equal(t, []byte("try"), msg)
-		require.Equal(t, chID, ch)
-
 		// Connections should still be active after closing the transports.
 		err = a.Close()
 		require.NoError(t, err)
 		err = b.Close()
 		require.NoError(t, err)
 
-		_, err = ab.SendMessage(chID, []byte("still here"))
+		err = ab.SendMessage(chID, []byte("still here"))
 		require.NoError(t, err)
 		ch, msg, err = ba.ReceiveMessage()
 		require.NoError(t, err)
@@ -403,37 +386,21 @@ func TestConnection_SendReceive(t *testing.T) {
 		_, _, err = ab.ReceiveMessage()
 		require.Error(t, err)
 		require.Equal(t, io.EOF, err)
-		_, err = ab.TrySendMessage(chID, []byte("closed try"))
-		require.Error(t, err)
-		require.Equal(t, io.EOF, err)
-		_, err = ab.SendMessage(chID, []byte("closed"))
+
+		err = ab.SendMessage(chID, []byte("closed"))
 		require.Error(t, err)
 		require.Equal(t, io.EOF, err)
 
 		_, _, err = ba.ReceiveMessage()
 		require.Error(t, err)
 		require.Equal(t, io.EOF, err)
-		_, err = ba.TrySendMessage(chID, []byte("closed try"))
-		require.Error(t, err)
-		require.Equal(t, io.EOF, err)
-		_, err = ba.SendMessage(chID, []byte("closed"))
+
+		err = ba.SendMessage(chID, []byte("closed"))
 		require.Error(t, err)
 		require.Equal(t, io.EOF, err)
 	})
 }
 
-func TestConnection_Status(t *testing.T) {
-	withTransports(t, func(t *testing.T, makeTransport transportFactory) {
-		a := makeTransport(t)
-		b := makeTransport(t)
-		ab, _ := dialAcceptHandshake(t, a, b)
-
-		// FIXME: This isn't implemented in all transports, so for now we just
-		// check that it doesn't panic, which isn't really much of a test.
-		ab.Status()
-	})
-}
-
 func TestConnection_String(t *testing.T) {
 	withTransports(t, func(t *testing.T, makeTransport transportFactory) {
 		a := makeTransport(t)
diff --git a/internal/p2p/types.go b/internal/p2p/types.go
index 403f43528d..388ff2253b 100644
--- a/internal/p2p/types.go
+++ b/internal/p2p/types.go
@@ -5,4 +5,3 @@ import (
 )
 
 type ChannelDescriptor = conn.ChannelDescriptor
-type ConnectionStatus = conn.ConnectionStatus
diff --git a/node/node.go b/node/node.go
index 891c5fce65..eeb3016148 100644
--- a/node/node.go
+++ b/node/node.go
@@ -1043,10 +1043,6 @@ func getRouterConfig(conf *config.Config, proxyApp proxy.AppConns) p2p.RouterOpt
 		QueueType: conf.P2P.QueueType,
 	}
 
-	if conf.P2P.MaxNumInboundPeers > 0 {
-		opts.MaxIncomingConnectionAttempts = conf.P2P.MaxIncomingConnectionAttempts
-	}
-
 	if conf.FilterPeers && proxyApp != nil {
 		opts.FilterPeerByID = func(ctx context.Context, id types.NodeID) error {
 			res, err := proxyApp.Query().QuerySync(context.Background(), abci.RequestQuery{
diff --git a/node/setup.go b/node/setup.go
index 8889edc4ea..893d7ccde3 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -3,7 +3,6 @@ package node
 import (
 	"bytes"
 	"fmt"
-	"math"
 	"time"
 
 	dbm "github.com/tendermint/tm-db"
@@ -18,6 +17,7 @@ import (
 	mempoolv0 "github.com/tendermint/tendermint/internal/mempool/v0"
 	mempoolv1 "github.com/tendermint/tendermint/internal/mempool/v1"
 	"github.com/tendermint/tendermint/internal/p2p"
+	"github.com/tendermint/tendermint/internal/p2p/conn"
 	"github.com/tendermint/tendermint/internal/p2p/pex"
 	"github.com/tendermint/tendermint/internal/proxy"
 	sm "github.com/tendermint/tendermint/internal/state"
@@ -344,11 +344,9 @@ func createConsensusReactor(
 
 func createTransport(logger log.Logger, cfg *config.Config) *p2p.MConnTransport {
 	return p2p.NewMConnTransport(
-		logger, p2p.MConnConfig(cfg.P2P), []*p2p.ChannelDescriptor{},
+		logger, conn.DefaultMConnConfig(), []*p2p.ChannelDescriptor{},
 		p2p.MConnTransportOptions{
-			MaxAcceptedConnections: uint32(cfg.P2P.MaxNumInboundPeers +
-				len(tmstrings.SplitAndTrimEmpty(cfg.P2P.UnconditionalPeerIDs, ",", " ")),
-			),
+			MaxAcceptedConnections: uint32(cfg.P2P.MaxConnections),
 		},
 	)
 }
@@ -365,20 +363,6 @@ func createPeerManager(
 	switch {
 	case cfg.P2P.MaxConnections > 0:
 		maxConns = cfg.P2P.MaxConnections
-
-	case cfg.P2P.MaxNumInboundPeers > 0 && cfg.P2P.MaxNumOutboundPeers > 0:
-		x := cfg.P2P.MaxNumInboundPeers + cfg.P2P.MaxNumOutboundPeers
-		if x > math.MaxUint16 {
-			return nil, fmt.Errorf(
-				"max inbound peers (%d) + max outbound peers (%d) exceeds maximum (%d)",
-				cfg.P2P.MaxNumInboundPeers,
-				cfg.P2P.MaxNumOutboundPeers,
-				math.MaxUint16,
-			)
-		}
-
-		maxConns = uint16(x)
-
 	default:
 		maxConns = 64
 	}
diff --git a/rpc/client/helpers.go b/rpc/client/helpers.go
index 289d947a9f..58e48dbba6 100644
--- a/rpc/client/helpers.go
+++ b/rpc/client/helpers.go
@@ -79,7 +79,7 @@ func WaitForOneEvent(c EventsClient, eventValue string, timeout time.Duration) (
 
 	select {
 	case event := <-eventCh:
-		return event.Data.(types.TMEventData), nil
+		return event.Data, nil
 	case <-ctx.Done():
 		return nil, errors.New("timed out waiting for event")
 	}
diff --git a/test/e2e/runner/setup.go b/test/e2e/runner/setup.go
index 3b1184e9ce..9bf76c874e 100644
--- a/test/e2e/runner/setup.go
+++ b/test/e2e/runner/setup.go
@@ -237,7 +237,6 @@ func MakeConfig(node *e2e.Node) (*config.Config, error) {
 	cfg.RPC.ListenAddress = "tcp://0.0.0.0:26657"
 	cfg.RPC.PprofListenAddress = ":6060"
 	cfg.P2P.ExternalAddress = fmt.Sprintf("tcp://%v", node.AddressP2P(false))
-	cfg.P2P.AddrBookStrict = false
 	cfg.P2P.QueueType = node.QueueType
 	cfg.DBBackend = node.Database
 	cfg.StateSync.DiscoveryTime = 5 * time.Second

From 1f438f205a10c83a4588b4fd838b3235684b1782 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Thu, 7 Oct 2021 19:07:35 -0400
Subject: [PATCH 28/57] e2e: improve network connectivity (#7077)

This tweaks the connectivity of test configurations, in hopes that more will be viable.

Additionally reduces the prevalence of testing the legacy mempool.
---
 test/e2e/generator/generate.go      | 34 ++++++++++++-----------------
 test/e2e/generator/generate_test.go |  4 ++--
 test/e2e/pkg/testnet.go             |  2 +-
 3 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index 21b3ebe0aa..75342f4e74 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -44,9 +44,10 @@ var (
 		"tcp":  20,
 		"unix": 10,
 	}
-	// FIXME: v2 disabled due to flake
-	nodeBlockSyncs = uniformChoice{"v0"} // "v2"
-	nodeMempools   = uniformChoice{"v0", "v1"}
+	nodeMempools = weightedChoice{
+		"v0": 20,
+		"v1": 80,
+	}
 	nodeStateSyncs = weightedChoice{
 		e2e.StateSyncDisabled: 10,
 		e2e.StateSyncP2P:      45,
@@ -54,8 +55,12 @@ var (
 	}
 	nodePersistIntervals  = uniformChoice{0, 1, 5}
 	nodeSnapshotIntervals = uniformChoice{0, 5}
-	nodeRetainBlocks      = uniformChoice{0, 2 * int(e2e.EvidenceAgeHeight), 4 * int(e2e.EvidenceAgeHeight)}
-	nodePerturbations     = probSetChoice{
+	nodeRetainBlocks      = uniformChoice{
+		0,
+		2 * int(e2e.EvidenceAgeHeight),
+		4 * int(e2e.EvidenceAgeHeight),
+	}
+	nodePerturbations = probSetChoice{
 		"disconnect": 0.1,
 		"pause":      0.1,
 		"kill":       0.1,
@@ -236,13 +241,9 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 
 			// choose one of the seeds
 			manifest.Nodes[name].Seeds = uniformSetChoice(seedNames).Choose(r)
-		} else if i > 0 {
+		} else if i > 1 && r.Float64() >= 0.5 {
 			peers := uniformSetChoice(peerNames[:i])
-			if manifest.Nodes[name].StateSync == e2e.StateSyncP2P {
-				manifest.Nodes[name].PersistentPeers = peers.ChooseAtLeast(r, 2)
-			} else {
-				manifest.Nodes[name].PersistentPeers = peers.Choose(r)
-			}
+			manifest.Nodes[name].PersistentPeers = peers.ChooseAtLeast(r, 2)
 		}
 	}
 
@@ -250,9 +251,7 @@ func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, er
 	for i := 1; i <= numLightClients; i++ {
 		startAt := manifest.InitialHeight + 5
 
-		node := generateLightNode(
-			r, startAt+(5*int64(i)), lightProviders,
-		)
+		node := generateLightNode(r, startAt+(5*int64(i)), lightProviders)
 
 		manifest.Nodes[fmt.Sprintf("light%02d", i)] = node
 
@@ -278,8 +277,7 @@ func generateNode(
 		Database:         nodeDatabases.Choose(r),
 		ABCIProtocol:     nodeABCIProtocols.Choose(r),
 		PrivvalProtocol:  nodePrivvalProtocols.Choose(r),
-		BlockSync:        nodeBlockSyncs.Choose(r).(string),
-		Mempool:          nodeMempools.Choose(r).(string),
+		Mempool:          nodeMempools.Choose(r),
 		StateSync:        e2e.StateSyncDisabled,
 		PersistInterval:  ptrUint64(uint64(nodePersistIntervals.Choose(r).(int))),
 		SnapshotInterval: uint64(nodeSnapshotIntervals.Choose(r).(int)),
@@ -326,10 +324,6 @@ func generateNode(
 		}
 	}
 
-	if node.StateSync != e2e.StateSyncDisabled {
-		node.BlockSync = "v0"
-	}
-
 	return &node
 }
 
diff --git a/test/e2e/generator/generate_test.go b/test/e2e/generator/generate_test.go
index b7f7902590..79a20f27e8 100644
--- a/test/e2e/generator/generate_test.go
+++ b/test/e2e/generator/generate_test.go
@@ -31,8 +31,8 @@ func TestGenerator(t *testing.T) {
 					}
 					if node.StateSync != e2e.StateSyncDisabled {
 						require.Zero(t, node.Seeds, node.StateSync)
-						require.True(t, len(node.PersistentPeers) >= 2)
-						require.Equal(t, "v0", node.BlockSync)
+						require.True(t, len(node.PersistentPeers) >= 2 || len(node.PersistentPeers) == 0,
+							"peers: %v", node.PersistentPeers)
 					}
 
 				})
diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go
index 1daa8b87ca..a6d5b2485d 100644
--- a/test/e2e/pkg/testnet.go
+++ b/test/e2e/pkg/testnet.go
@@ -172,7 +172,7 @@ func LoadTestnet(file string) (*Testnet, error) {
 			ABCIProtocol:     ProtocolBuiltin,
 			PrivvalProtocol:  ProtocolFile,
 			StartAt:          nodeManifest.StartAt,
-			BlockSync:        nodeManifest.BlockSync,
+			BlockSync:        "v0",
 			Mempool:          nodeManifest.Mempool,
 			StateSync:        nodeManifest.StateSync,
 			PersistInterval:  1,

From 4ca130d226189361651bd91d1738c623048a6f46 Mon Sep 17 00:00:00 2001
From: Callum Waters <cmwaters19@gmail.com>
Date: Fri, 8 Oct 2021 09:15:13 +0200
Subject: [PATCH 29/57] cli: allow node operator to rollback last state (#7033)

---
 CHANGELOG_PENDING.md                     |   1 +
 cmd/tendermint/commands/reindex_event.go |  11 +-
 cmd/tendermint/commands/rollback.go      |  46 +++++++
 cmd/tendermint/main.go                   |   1 +
 internal/state/rollback.go               |  87 ++++++++++++++
 internal/state/rollback_test.go          | 146 +++++++++++++++++++++++
 internal/state/state.go                  |   2 +
 test/e2e/app/app.go                      |   6 +
 8 files changed, 295 insertions(+), 5 deletions(-)
 create mode 100644 cmd/tendermint/commands/rollback.go
 create mode 100644 internal/state/rollback.go
 create mode 100644 internal/state/rollback_test.go

diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md
index 9d7ea96aeb..fafb9cea73 100644
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -30,6 +30,7 @@ Special thanks to external contributors on this release:
 
 ### FEATURES
 
+- [cli] [#7033](https://github.com/tendermint/tendermint/pull/7033) Add a `rollback` command to rollback to the previous tendermint state in the event of non-determinstic app hash or reverting an upgrade.
 - [mempool, rpc] \#7041  Add removeTx operation to the RPC layer. (@tychoish)
 
 ### IMPROVEMENTS
diff --git a/cmd/tendermint/commands/reindex_event.go b/cmd/tendermint/commands/reindex_event.go
index 9545e32d7a..58f11657b2 100644
--- a/cmd/tendermint/commands/reindex_event.go
+++ b/cmd/tendermint/commands/reindex_event.go
@@ -29,11 +29,12 @@ var ReIndexEventCmd = &cobra.Command{
 	Use:   "reindex-event",
 	Short: "reindex events to the event store backends",
 	Long: `
-	reindex-event is an offline tooling to re-index block and tx events to the eventsinks,
-	you can run this command when the event store backend dropped/disconnected or you want to replace the backend.
-	The default start-height is 0, meaning the tooling will start reindex from the base block height(inclusive); and the
-	default end-height is 0, meaning the tooling will reindex until the latest block height(inclusive). User can omits
-	either or both arguments.
+reindex-event is an offline tooling to re-index block and tx events to the eventsinks,
+you can run this command when the event store backend dropped/disconnected or you want to 
+replace the backend. The default start-height is 0, meaning the tooling will start 
+reindex from the base block height(inclusive); and the default end-height is 0, meaning 
+the tooling will reindex until the latest block height(inclusive). User can omit
+either or both arguments.
 	`,
 	Example: `
 	tendermint reindex-event
diff --git a/cmd/tendermint/commands/rollback.go b/cmd/tendermint/commands/rollback.go
new file mode 100644
index 0000000000..5aff232beb
--- /dev/null
+++ b/cmd/tendermint/commands/rollback.go
@@ -0,0 +1,46 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+
+	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/internal/state"
+)
+
+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.
+The application should also roll back to height n - 1. No blocks are removed, so upon
+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(config)
+		if err != nil {
+			return fmt.Errorf("failed to rollback state: %w", err)
+		}
+
+		fmt.Printf("Rolled back state to height %d and hash %v", 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 *cfg.Config) (int64, []byte, error) {
+	// use the parsed config to load the block and state store
+	blockStore, stateStore, err := loadStateAndBlockStore(config)
+	if err != nil {
+		return -1, nil, err
+	}
+
+	// rollback the last state
+	return state.Rollback(blockStore, stateStore)
+}
diff --git a/cmd/tendermint/main.go b/cmd/tendermint/main.go
index 9f908a1ed1..52a00e4c06 100644
--- a/cmd/tendermint/main.go
+++ b/cmd/tendermint/main.go
@@ -29,6 +29,7 @@ func main() {
 		cmd.GenNodeKeyCmd,
 		cmd.VersionCmd,
 		cmd.InspectCmd,
+		cmd.RollbackStateCmd,
 		cmd.MakeKeyMigrateCommand(),
 		debug.DebugCmd,
 		cli.NewCompletionCmd(rootCmd, true),
diff --git a/internal/state/rollback.go b/internal/state/rollback.go
new file mode 100644
index 0000000000..6e13da0e29
--- /dev/null
+++ b/internal/state/rollback.go
@@ -0,0 +1,87 @@
+package state
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/tendermint/tendermint/version"
+)
+
+// Rollback overwrites the current Tendermint state (height n) with the most
+// recent previous state (height n - 1).
+// Note that this function does not affect application state.
+func Rollback(bs BlockStore, ss Store) (int64, []byte, error) {
+	invalidState, err := ss.Load()
+	if err != nil {
+		return -1, nil, err
+	}
+	if invalidState.IsEmpty() {
+		return -1, nil, errors.New("no state found")
+	}
+
+	rollbackHeight := invalidState.LastBlockHeight
+	rollbackBlock := bs.LoadBlockMeta(rollbackHeight)
+	if rollbackBlock == nil {
+		return -1, nil, fmt.Errorf("block at height %d not found", rollbackHeight)
+	}
+
+	previousValidatorSet, err := ss.LoadValidators(rollbackHeight - 1)
+	if err != nil {
+		return -1, nil, err
+	}
+
+	previousParams, err := ss.LoadConsensusParams(rollbackHeight)
+	if err != nil {
+		return -1, nil, err
+	}
+
+	valChangeHeight := invalidState.LastHeightValidatorsChanged
+	// this can only happen if the validator set changed since the last block
+	if valChangeHeight > rollbackHeight {
+		valChangeHeight = rollbackHeight
+	}
+
+	paramsChangeHeight := invalidState.LastHeightConsensusParamsChanged
+	// this can only happen if params changed from the last block
+	if paramsChangeHeight > rollbackHeight {
+		paramsChangeHeight = rollbackHeight
+	}
+
+	// build the new state from the old state and the prior block
+	rolledBackState := State{
+		Version: Version{
+			Consensus: version.Consensus{
+				Block: version.BlockProtocol,
+				App:   previousParams.Version.AppVersion,
+			},
+			Software: version.TMVersion,
+		},
+		// immutable fields
+		ChainID:       invalidState.ChainID,
+		InitialHeight: invalidState.InitialHeight,
+
+		LastBlockHeight: invalidState.LastBlockHeight - 1,
+		LastBlockID:     rollbackBlock.Header.LastBlockID,
+		LastBlockTime:   rollbackBlock.Header.Time,
+
+		NextValidators:              invalidState.Validators,
+		Validators:                  invalidState.LastValidators,
+		LastValidators:              previousValidatorSet,
+		LastHeightValidatorsChanged: valChangeHeight,
+
+		ConsensusParams:                  previousParams,
+		LastHeightConsensusParamsChanged: paramsChangeHeight,
+
+		LastResultsHash: rollbackBlock.Header.LastResultsHash,
+		AppHash:         rollbackBlock.Header.AppHash,
+	}
+
+	// persist the new state. This overrides the invalid one. NOTE: this will also
+	// persist the validator set and consensus params over the existing structures,
+	// but both should be the same
+	if err := ss.Save(rolledBackState); err != nil {
+		return -1, nil, fmt.Errorf("failed to save rolled back state: %w", err)
+	}
+
+	return rolledBackState.LastBlockHeight, rolledBackState.AppHash, nil
+}
diff --git a/internal/state/rollback_test.go b/internal/state/rollback_test.go
new file mode 100644
index 0000000000..ae5c8ee84a
--- /dev/null
+++ b/internal/state/rollback_test.go
@@ -0,0 +1,146 @@
+package state_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	dbm "github.com/tendermint/tm-db"
+
+	"github.com/tendermint/tendermint/internal/state"
+	"github.com/tendermint/tendermint/internal/state/mocks"
+	"github.com/tendermint/tendermint/internal/test/factory"
+	"github.com/tendermint/tendermint/types"
+	"github.com/tendermint/tendermint/version"
+)
+
+func TestRollback(t *testing.T) {
+	stateStore := state.NewStore(dbm.NewMemDB())
+	blockStore := &mocks.BlockStore{}
+	var (
+		height     int64  = 100
+		appVersion uint64 = 10
+	)
+
+	valSet, _ := factory.RandValidatorSet(5, 10)
+
+	params := types.DefaultConsensusParams()
+	params.Version.AppVersion = appVersion
+	newParams := types.DefaultConsensusParams()
+	newParams.Block.MaxBytes = 10000
+
+	initialState := state.State{
+		Version: state.Version{
+			Consensus: version.Consensus{
+				Block: version.BlockProtocol,
+				App:   10,
+			},
+			Software: version.TMVersion,
+		},
+		ChainID:                          factory.DefaultTestChainID,
+		InitialHeight:                    10,
+		LastBlockID:                      factory.MakeBlockID(),
+		AppHash:                          factory.RandomHash(),
+		LastResultsHash:                  factory.RandomHash(),
+		LastBlockHeight:                  height,
+		LastValidators:                   valSet,
+		Validators:                       valSet.CopyIncrementProposerPriority(1),
+		NextValidators:                   valSet.CopyIncrementProposerPriority(2),
+		LastHeightValidatorsChanged:      height + 1,
+		ConsensusParams:                  *params,
+		LastHeightConsensusParamsChanged: height + 1,
+	}
+	require.NoError(t, stateStore.Bootstrap(initialState))
+
+	height++
+	block := &types.BlockMeta{
+		Header: types.Header{
+			Height:          height,
+			AppHash:         initialState.AppHash,
+			LastBlockID:     initialState.LastBlockID,
+			LastResultsHash: initialState.LastResultsHash,
+		},
+	}
+	blockStore.On("LoadBlockMeta", height).Return(block)
+
+	appVersion++
+	newParams.Version.AppVersion = appVersion
+	nextState := initialState.Copy()
+	nextState.LastBlockHeight = height
+	nextState.Version.Consensus.App = appVersion
+	nextState.LastBlockID = factory.MakeBlockID()
+	nextState.AppHash = factory.RandomHash()
+	nextState.LastValidators = initialState.Validators
+	nextState.Validators = initialState.NextValidators
+	nextState.NextValidators = initialState.NextValidators.CopyIncrementProposerPriority(1)
+	nextState.ConsensusParams = *newParams
+	nextState.LastHeightConsensusParamsChanged = height + 1
+	nextState.LastHeightValidatorsChanged = height + 1
+
+	// update the state
+	require.NoError(t, stateStore.Save(nextState))
+
+	// rollback the state
+	rollbackHeight, rollbackHash, err := state.Rollback(blockStore, stateStore)
+	require.NoError(t, err)
+	require.EqualValues(t, int64(100), rollbackHeight)
+	require.EqualValues(t, initialState.AppHash, rollbackHash)
+	blockStore.AssertExpectations(t)
+
+	// assert that we've recovered the prior state
+	loadedState, err := stateStore.Load()
+	require.NoError(t, err)
+	require.EqualValues(t, initialState, loadedState)
+}
+
+func TestRollbackNoState(t *testing.T) {
+	stateStore := state.NewStore(dbm.NewMemDB())
+	blockStore := &mocks.BlockStore{}
+
+	_, _, err := state.Rollback(blockStore, stateStore)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "no state found")
+}
+
+func TestRollbackNoBlocks(t *testing.T) {
+	stateStore := state.NewStore(dbm.NewMemDB())
+	blockStore := &mocks.BlockStore{}
+	var (
+		height     int64  = 100
+		appVersion uint64 = 10
+	)
+
+	valSet, _ := factory.RandValidatorSet(5, 10)
+
+	params := types.DefaultConsensusParams()
+	params.Version.AppVersion = appVersion
+	newParams := types.DefaultConsensusParams()
+	newParams.Block.MaxBytes = 10000
+
+	initialState := state.State{
+		Version: state.Version{
+			Consensus: version.Consensus{
+				Block: version.BlockProtocol,
+				App:   10,
+			},
+			Software: version.TMVersion,
+		},
+		ChainID:                          factory.DefaultTestChainID,
+		InitialHeight:                    10,
+		LastBlockID:                      factory.MakeBlockID(),
+		AppHash:                          factory.RandomHash(),
+		LastResultsHash:                  factory.RandomHash(),
+		LastBlockHeight:                  height,
+		LastValidators:                   valSet,
+		Validators:                       valSet.CopyIncrementProposerPriority(1),
+		NextValidators:                   valSet.CopyIncrementProposerPriority(2),
+		LastHeightValidatorsChanged:      height + 1,
+		ConsensusParams:                  *params,
+		LastHeightConsensusParamsChanged: height + 1,
+	}
+	require.NoError(t, stateStore.Save(initialState))
+	blockStore.On("LoadBlockMeta", height).Return(nil)
+
+	_, _, err := state.Rollback(blockStore, stateStore)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "block at height 100 not found")
+}
diff --git a/internal/state/state.go b/internal/state/state.go
index 5862162d15..ce9990cc25 100644
--- a/internal/state/state.go
+++ b/internal/state/state.go
@@ -64,6 +64,8 @@ func VersionFromProto(v tmstate.Version) Version {
 // Instead, use state.Copy() or updateState(...).
 // NOTE: not goroutine-safe.
 type State struct {
+	// FIXME: This can be removed as TMVersion is a constant, and version.Consensus should
+	// eventually be replaced by VersionParams in ConsensusParams
 	Version Version
 
 	// immutable
diff --git a/test/e2e/app/app.go b/test/e2e/app/app.go
index e7ba110e9e..395c870249 100644
--- a/test/e2e/app/app.go
+++ b/test/e2e/app/app.go
@@ -11,6 +11,7 @@ import (
 	"github.com/tendermint/tendermint/abci/example/code"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tendermint/tendermint/proto/tendermint/types"
 	"github.com/tendermint/tendermint/version"
 )
 
@@ -116,6 +117,11 @@ func (app *Application) InitChain(req abci.RequestInitChain) abci.ResponseInitCh
 	}
 	resp := abci.ResponseInitChain{
 		AppHash: app.state.Hash,
+		ConsensusParams: &types.ConsensusParams{
+			Version: &types.VersionParams{
+				AppVersion: 1,
+			},
+		},
 	}
 	if resp.Validators, err = app.validatorUpdates(0); err != nil {
 		panic(err)

From 1b5bb5348f0bf660efd294ecf059458251ee0511 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 8 Oct 2021 08:49:17 -0400
Subject: [PATCH 30/57] p2p: cleanup unused arguments (#7079)

This is mostly just reading through the output of uparam, after
noticing that there were a few places where we were ignoring some arguments.
---
 internal/p2p/router.go                 | 18 +++++++++---------
 internal/statesync/block_queue.go      |  2 +-
 internal/statesync/block_queue_test.go |  8 ++++----
 internal/statesync/reactor.go          |  2 +-
 node/node.go                           | 10 +++++-----
 node/setup.go                          |  3 ---
 test/e2e/node/main.go                  |  4 ++--
 7 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index ed61194316..8b96bc93a0 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -610,7 +610,7 @@ func (r *Router) openConnection(ctx context.Context, conn Connection) {
 	// The Router should do the handshake and have a final ack/fail
 	// message to make sure both ends have accepted the connection, such
 	// that it can be coordinated with the peer manager.
-	peerInfo, _, err := r.handshakePeer(ctx, conn, "")
+	peerInfo, err := r.handshakePeer(ctx, conn, "")
 	switch {
 	case errors.Is(err, context.Canceled):
 		return
@@ -704,7 +704,7 @@ func (r *Router) connectPeer(ctx context.Context, address NodeAddress) {
 		return
 	}
 
-	peerInfo, _, err := r.handshakePeer(ctx, conn, address.NodeID)
+	peerInfo, err := r.handshakePeer(ctx, conn, address.NodeID)
 	switch {
 	case errors.Is(err, context.Canceled):
 		conn.Close()
@@ -799,7 +799,7 @@ func (r *Router) handshakePeer(
 	ctx context.Context,
 	conn Connection,
 	expectID types.NodeID,
-) (types.NodeInfo, crypto.PubKey, error) {
+) (types.NodeInfo, error) {
 
 	if r.options.HandshakeTimeout > 0 {
 		var cancel context.CancelFunc
@@ -809,27 +809,27 @@ func (r *Router) handshakePeer(
 
 	peerInfo, peerKey, err := conn.Handshake(ctx, r.nodeInfo, r.privKey)
 	if err != nil {
-		return peerInfo, peerKey, err
+		return peerInfo, err
 	}
 	if err = peerInfo.Validate(); err != nil {
-		return peerInfo, peerKey, fmt.Errorf("invalid handshake NodeInfo: %w", err)
+		return peerInfo, fmt.Errorf("invalid handshake NodeInfo: %w", err)
 	}
 	if types.NodeIDFromPubKey(peerKey) != peerInfo.NodeID {
-		return peerInfo, peerKey, fmt.Errorf("peer's public key did not match its node ID %q (expected %q)",
+		return peerInfo, fmt.Errorf("peer's public key did not match its node ID %q (expected %q)",
 			peerInfo.NodeID, types.NodeIDFromPubKey(peerKey))
 	}
 	if expectID != "" && expectID != peerInfo.NodeID {
-		return peerInfo, peerKey, fmt.Errorf("expected to connect with peer %q, got %q",
+		return peerInfo, fmt.Errorf("expected to connect with peer %q, got %q",
 			expectID, peerInfo.NodeID)
 	}
 	if err := r.nodeInfo.CompatibleWith(peerInfo); err != nil {
-		return peerInfo, peerKey, ErrRejected{
+		return peerInfo, ErrRejected{
 			err:            err,
 			id:             peerInfo.ID(),
 			isIncompatible: true,
 		}
 	}
-	return peerInfo, peerKey, nil
+	return peerInfo, nil
 }
 
 func (r *Router) runWithPeerMutex(fn func() error) error {
diff --git a/internal/statesync/block_queue.go b/internal/statesync/block_queue.go
index 56ed3c3762..80b0ffbd52 100644
--- a/internal/statesync/block_queue.go
+++ b/internal/statesync/block_queue.go
@@ -200,7 +200,7 @@ func (q *blockQueue) retry(height int64) {
 
 // Success is called when a light block has been successfully verified and
 // processed
-func (q *blockQueue) success(height int64) {
+func (q *blockQueue) success() {
 	q.mtx.Lock()
 	defer q.mtx.Unlock()
 	if q.terminal != nil && q.verifyHeight == q.terminal.Height {
diff --git a/internal/statesync/block_queue_test.go b/internal/statesync/block_queue_test.go
index dc5e2bc82d..ad28efac94 100644
--- a/internal/statesync/block_queue_test.go
+++ b/internal/statesync/block_queue_test.go
@@ -58,7 +58,7 @@ loop:
 			// assert that the queue serializes the blocks
 			require.Equal(t, resp.block.Height, trackingHeight)
 			trackingHeight--
-			queue.success(resp.block.Height)
+			queue.success()
 		}
 
 	}
@@ -105,7 +105,7 @@ func TestBlockQueueWithFailures(t *testing.T) {
 				queue.retry(resp.block.Height)
 			} else {
 				trackingHeight--
-				queue.success(resp.block.Height)
+				queue.success()
 			}
 
 		case <-queue.done():
@@ -223,7 +223,7 @@ func TestBlockQueueStopTime(t *testing.T) {
 			// assert that the queue serializes the blocks
 			assert.Equal(t, resp.block.Height, trackingHeight)
 			trackingHeight--
-			queue.success(resp.block.Height)
+			queue.success()
 
 		case <-queue.done():
 			wg.Wait()
@@ -268,7 +268,7 @@ loop:
 
 		case resp := <-queue.verifyNext():
 			require.GreaterOrEqual(t, resp.block.Height, initialHeight)
-			queue.success(resp.block.Height)
+			queue.success()
 		}
 	}
 }
diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index 70b12b7fa4..98ace6e371 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -509,7 +509,7 @@ func (r *Reactor) backfill(
 			}
 
 			trustedBlockID = resp.block.LastBlockID
-			queue.success(resp.block.Height)
+			queue.success()
 			r.Logger.Info("backfill: verified and stored light block", "height", resp.block.Height)
 
 			lastValidatorSet = resp.block.ValidatorSet
diff --git a/node/node.go b/node/node.go
index eeb3016148..580121050b 100644
--- a/node/node.go
+++ b/node/node.go
@@ -235,7 +235,7 @@ func makeNode(cfg *config.Config,
 	p2pLogger := logger.With("module", "p2p")
 	transport := createTransport(p2pLogger, cfg)
 
-	peerManager, err := createPeerManager(cfg, dbProvider, p2pLogger, nodeKey.ID)
+	peerManager, err := createPeerManager(cfg, dbProvider, nodeKey.ID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create peer manager: %w", err)
 	}
@@ -283,7 +283,7 @@ func makeNode(cfg *config.Config,
 	// Create the blockchain reactor. Note, we do not start block sync if we're
 	// doing a state sync first.
 	bcReactorShim, bcReactor, err := createBlockchainReactor(
-		logger, cfg, state, blockExec, blockStore, csReactor,
+		logger, state, blockExec, blockStore, csReactor,
 		peerManager, router, blockSync && !stateSync, nodeMetrics.consensus,
 	)
 	if err != nil {
@@ -352,7 +352,7 @@ func makeNode(cfg *config.Config,
 	pexCh := pex.ChannelDescriptor()
 	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
 
-	pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router)
+	pexReactor, err = createPEXReactorV2(logger, peerManager, router)
 	if err != nil {
 		return nil, err
 	}
@@ -446,7 +446,7 @@ func makeSeedNode(cfg *config.Config,
 	p2pLogger := logger.With("module", "p2p")
 	transport := createTransport(p2pLogger, cfg)
 
-	peerManager, err := createPeerManager(cfg, dbProvider, p2pLogger, nodeKey.ID)
+	peerManager, err := createPeerManager(cfg, dbProvider, nodeKey.ID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create peer manager: %w", err)
 	}
@@ -466,7 +466,7 @@ func makeSeedNode(cfg *config.Config,
 	pexCh := pex.ChannelDescriptor()
 	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
 
-	pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router)
+	pexReactor, err = createPEXReactorV2(logger, peerManager, router)
 	if err != nil {
 		return nil, err
 	}
diff --git a/node/setup.go b/node/setup.go
index 893d7ccde3..b7a2d19afa 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -254,7 +254,6 @@ func createEvidenceReactor(
 
 func createBlockchainReactor(
 	logger log.Logger,
-	cfg *config.Config,
 	state sm.State,
 	blockExec *sm.BlockExecutor,
 	blockStore *store.BlockStore,
@@ -354,7 +353,6 @@ func createTransport(logger log.Logger, cfg *config.Config) *p2p.MConnTransport
 func createPeerManager(
 	cfg *config.Config,
 	dbProvider config.DBProvider,
-	p2pLogger log.Logger,
 	nodeID types.NodeID,
 ) (*p2p.PeerManager, error) {
 
@@ -443,7 +441,6 @@ func createRouter(
 }
 
 func createPEXReactorV2(
-	cfg *config.Config,
 	logger log.Logger,
 	peerManager *p2p.PeerManager,
 	router *p2p.Router,
diff --git a/test/e2e/node/main.go b/test/e2e/node/main.go
index 222a6883fa..b5d9debe94 100644
--- a/test/e2e/node/main.go
+++ b/test/e2e/node/main.go
@@ -79,7 +79,7 @@ func run(configFile string) error {
 		case string(e2e.ModeLight):
 			err = startLightNode(cfg)
 		case string(e2e.ModeSeed):
-			err = startSeedNode(cfg)
+			err = startSeedNode()
 		default:
 			err = startNode(cfg)
 		}
@@ -140,7 +140,7 @@ func startNode(cfg *Config) error {
 	return n.Start()
 }
 
-func startSeedNode(cfg *Config) error {
+func startSeedNode() error {
 	tmcfg, nodeLogger, err := setupNode()
 	if err != nil {
 		return fmt.Errorf("failed to setup config: %w", err)

From f2a8f5e054cf99ebe246818bb6d71f41f9a30faa Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 8 Oct 2021 09:42:23 -0400
Subject: [PATCH 31/57] e2e: abci protocol should be consistent across networks
 (#7078)

It seems weird in retrospect that we allow networks to contain
applications that use different ABCI protocols.
---
 test/e2e/generator/generate.go |  3 +--
 test/e2e/pkg/manifest.go       | 12 ++++++------
 test/e2e/pkg/testnet.go        | 10 ++++++----
 3 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/test/e2e/generator/generate.go b/test/e2e/generator/generate.go
index 75342f4e74..61b4bf7d38 100644
--- a/test/e2e/generator/generate.go
+++ b/test/e2e/generator/generate.go
@@ -108,6 +108,7 @@ type Options struct {
 func generateTestnet(r *rand.Rand, opt map[string]interface{}) (e2e.Manifest, error) {
 	manifest := e2e.Manifest{
 		IPv6:             ipv6.Choose(r).(bool),
+		ABCIProtocol:     nodeABCIProtocols.Choose(r),
 		InitialHeight:    int64(opt["initialHeight"].(int)),
 		InitialState:     opt["initialState"].(map[string]string),
 		Validators:       &map[string]int64{},
@@ -275,7 +276,6 @@ func generateNode(
 		Mode:             string(mode),
 		StartAt:          startAt,
 		Database:         nodeDatabases.Choose(r),
-		ABCIProtocol:     nodeABCIProtocols.Choose(r),
 		PrivvalProtocol:  nodePrivvalProtocols.Choose(r),
 		Mempool:          nodeMempools.Choose(r),
 		StateSync:        e2e.StateSyncDisabled,
@@ -332,7 +332,6 @@ func generateLightNode(r *rand.Rand, startAt int64, providers []string) *e2e.Man
 		Mode:            string(e2e.ModeLight),
 		StartAt:         startAt,
 		Database:        nodeDatabases.Choose(r),
-		ABCIProtocol:    "builtin",
 		PersistInterval: ptrUint64(0),
 		PersistentPeers: providers,
 	}
diff --git a/test/e2e/pkg/manifest.go b/test/e2e/pkg/manifest.go
index d5c9cb7f24..16b99cfdaa 100644
--- a/test/e2e/pkg/manifest.go
+++ b/test/e2e/pkg/manifest.go
@@ -65,6 +65,12 @@ type Manifest struct {
 
 	// Number of bytes per tx. Default is 1kb (1024)
 	TxSize int64
+
+	// ABCIProtocol specifies the protocol used to communicate with the ABCI
+	// application: "unix", "tcp", "grpc", or "builtin". Defaults to builtin.
+	// builtin will build a complete Tendermint node into the application and
+	// launch it instead of launching a separate Tendermint process.
+	ABCIProtocol string `toml:"abci_protocol"`
 }
 
 // ManifestNode represents a node in a testnet manifest.
@@ -87,12 +93,6 @@ type ManifestNode struct {
 	// "rocksdb", "boltdb", or "badgerdb". Defaults to goleveldb.
 	Database string `toml:"database"`
 
-	// ABCIProtocol specifies the protocol used to communicate with the ABCI
-	// application: "unix", "tcp", "grpc", or "builtin". Defaults to unix.
-	// builtin will build a complete Tendermint node into the application and
-	// launch it instead of launching a separate Tendermint process.
-	ABCIProtocol string `toml:"abci_protocol"`
-
 	// PrivvalProtocol specifies the protocol used to sign consensus messages:
 	// "file", "unix", "tcp", or "grpc". Defaults to "file". For tcp and unix, the ABCI
 	// application will launch a remote signer client in a separate goroutine.
diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go
index a6d5b2485d..ee6a283aa7 100644
--- a/test/e2e/pkg/testnet.go
+++ b/test/e2e/pkg/testnet.go
@@ -71,6 +71,7 @@ type Testnet struct {
 	Evidence         int
 	LogLevel         string
 	TxSize           int64
+	ABCIProtocol     string
 }
 
 // Node represents a Tendermint node in a testnet.
@@ -140,6 +141,7 @@ func LoadTestnet(file string) (*Testnet, error) {
 		KeyType:          "ed25519",
 		LogLevel:         manifest.LogLevel,
 		TxSize:           manifest.TxSize,
+		ABCIProtocol:     manifest.ABCIProtocol,
 	}
 	if len(manifest.KeyType) != 0 {
 		testnet.KeyType = manifest.KeyType
@@ -150,6 +152,9 @@ func LoadTestnet(file string) (*Testnet, error) {
 	if manifest.InitialHeight > 0 {
 		testnet.InitialHeight = manifest.InitialHeight
 	}
+	if testnet.ABCIProtocol == "" {
+		testnet.ABCIProtocol = string(ProtocolBuiltin)
+	}
 
 	// Set up nodes, in alphabetical order (IPs and ports get same order).
 	nodeNames := []string{}
@@ -169,7 +174,7 @@ func LoadTestnet(file string) (*Testnet, error) {
 			ProxyPort:        proxyPortGen.Next(),
 			Mode:             ModeValidator,
 			Database:         "goleveldb",
-			ABCIProtocol:     ProtocolBuiltin,
+			ABCIProtocol:     Protocol(testnet.ABCIProtocol),
 			PrivvalProtocol:  ProtocolFile,
 			StartAt:          nodeManifest.StartAt,
 			BlockSync:        "v0",
@@ -192,9 +197,6 @@ func LoadTestnet(file string) (*Testnet, error) {
 		if nodeManifest.Database != "" {
 			node.Database = nodeManifest.Database
 		}
-		if nodeManifest.ABCIProtocol != "" {
-			node.ABCIProtocol = Protocol(nodeManifest.ABCIProtocol)
-		}
 		if nodeManifest.PrivvalProtocol != "" {
 			node.PrivvalProtocol = Protocol(nodeManifest.PrivvalProtocol)
 		}

From 59404003eeb47797af8a9af8cb026abb7b68b0af Mon Sep 17 00:00:00 2001
From: Callum Waters <cmwaters19@gmail.com>
Date: Fri, 8 Oct 2021 16:53:54 +0200
Subject: [PATCH 32/57] p2p: rename pexV2 to pex (#7088)

---
 crypto/secp256k1/secp256k1_nocgo.go    |  1 +
 internal/consensus/wal_fuzz.go         |  1 +
 internal/libs/sync/deadlock.go         |  1 +
 internal/libs/sync/sync.go             |  1 +
 internal/p2p/conn/conn_go110.go        |  1 +
 internal/p2p/conn/conn_notgo110.go     |  1 +
 internal/p2p/pex/doc.go                |  9 ++----
 internal/p2p/pex/reactor.go            | 43 ++++++++++++--------------
 internal/p2p/pex/reactor_test.go       | 12 +++----
 node/node.go                           |  4 +--
 node/setup.go                          |  4 +--
 rpc/jsonrpc/client/integration_test.go |  1 +
 12 files changed, 38 insertions(+), 41 deletions(-)

diff --git a/crypto/secp256k1/secp256k1_nocgo.go b/crypto/secp256k1/secp256k1_nocgo.go
index cba9bbe4c3..6b52dc5d28 100644
--- a/crypto/secp256k1/secp256k1_nocgo.go
+++ b/crypto/secp256k1/secp256k1_nocgo.go
@@ -1,3 +1,4 @@
+//go:build !libsecp256k1
 // +build !libsecp256k1
 
 package secp256k1
diff --git a/internal/consensus/wal_fuzz.go b/internal/consensus/wal_fuzz.go
index e15097c305..06d894a812 100644
--- a/internal/consensus/wal_fuzz.go
+++ b/internal/consensus/wal_fuzz.go
@@ -1,3 +1,4 @@
+//go:build gofuzz
 // +build gofuzz
 
 package consensus
diff --git a/internal/libs/sync/deadlock.go b/internal/libs/sync/deadlock.go
index 637d6fbb17..21b5130ba4 100644
--- a/internal/libs/sync/deadlock.go
+++ b/internal/libs/sync/deadlock.go
@@ -1,3 +1,4 @@
+//go:build deadlock
 // +build deadlock
 
 package sync
diff --git a/internal/libs/sync/sync.go b/internal/libs/sync/sync.go
index a0880e7de9..c6e7101c60 100644
--- a/internal/libs/sync/sync.go
+++ b/internal/libs/sync/sync.go
@@ -1,3 +1,4 @@
+//go:build !deadlock
 // +build !deadlock
 
 package sync
diff --git a/internal/p2p/conn/conn_go110.go b/internal/p2p/conn/conn_go110.go
index 6821881015..459c3169b1 100644
--- a/internal/p2p/conn/conn_go110.go
+++ b/internal/p2p/conn/conn_go110.go
@@ -1,3 +1,4 @@
+//go:build go1.10
 // +build go1.10
 
 package conn
diff --git a/internal/p2p/conn/conn_notgo110.go b/internal/p2p/conn/conn_notgo110.go
index ed642eb549..21dffad2c2 100644
--- a/internal/p2p/conn/conn_notgo110.go
+++ b/internal/p2p/conn/conn_notgo110.go
@@ -1,3 +1,4 @@
+//go:build !go1.10
 // +build !go1.10
 
 package conn
diff --git a/internal/p2p/pex/doc.go b/internal/p2p/pex/doc.go
index dc4f5d37a5..70a5f61743 100644
--- a/internal/p2p/pex/doc.go
+++ b/internal/p2p/pex/doc.go
@@ -7,19 +7,14 @@ The PEX reactor is a continuous service which periodically requests addresses
 and serves addresses to other peers. There are two versions of this service
 aligning with the two p2p frameworks that Tendermint currently supports.
 
-V1 is coupled with the Switch (which handles peer connections and routing of
-messages) and, alongside exchanging peer information in the form of port/IP
-pairs, also has the responsibility of dialing peers and ensuring that a
-node has a sufficient amount of peers connected.
-
-V2 is embedded with the new p2p stack and uses the peer manager to advertise
+The reactor is embedded with the new p2p stack and uses the peer manager to advertise
 peers as well as add new peers to the peer store. The V2 reactor passes a
 different set of proto messages which include a list of
 [urls](https://golang.org/pkg/net/url/#URL).These can be used to save a set of
 endpoints that each peer uses. The V2 reactor has backwards compatibility with
 V1. It can also handle V1 messages.
 
-The V2 reactor is able to tweak the intensity of it's search by decreasing or
+The reactor is able to tweak the intensity of it's search by decreasing or
 increasing the interval between each request. It tracks connected peers via a
 linked list, sending a request to the node at the front of the list and adding
 it to the back of the list once a response is received. Using this method, a
diff --git a/internal/p2p/pex/reactor.go b/internal/p2p/pex/reactor.go
index 300a6022dd..f5c03adf8e 100644
--- a/internal/p2p/pex/reactor.go
+++ b/internal/p2p/pex/reactor.go
@@ -17,7 +17,7 @@ import (
 )
 
 var (
-	_ service.Service = (*ReactorV2)(nil)
+	_ service.Service = (*Reactor)(nil)
 	_ p2p.Wrapper     = (*protop2p.PexMessage)(nil)
 )
 
@@ -73,11 +73,6 @@ func ChannelDescriptor() conn.ChannelDescriptor {
 	}
 }
 
-// ReactorV2 is a PEX reactor for the new P2P stack. The legacy reactor
-// is Reactor.
-//
-// FIXME: Rename this when Reactor is removed, and consider moving to p2p/.
-//
 // The peer exchange or PEX reactor supports the peer manager by sending
 // requests to other peers for addresses that can be given to the peer manager
 // and at the same time advertises addresses to peers that need more.
@@ -86,7 +81,7 @@ func ChannelDescriptor() conn.ChannelDescriptor {
 // increasing the interval between each request. It tracks connected peers via
 // a linked list, sending a request to the node at the front of the list and
 // adding it to the back of the list once a response is received.
-type ReactorV2 struct {
+type Reactor struct {
 	service.BaseService
 
 	peerManager *p2p.PeerManager
@@ -125,14 +120,14 @@ type ReactorV2 struct {
 }
 
 // NewReactor returns a reference to a new reactor.
-func NewReactorV2(
+func NewReactor(
 	logger log.Logger,
 	peerManager *p2p.PeerManager,
 	pexCh *p2p.Channel,
 	peerUpdates *p2p.PeerUpdates,
-) *ReactorV2 {
+) *Reactor {
 
-	r := &ReactorV2{
+	r := &Reactor{
 		peerManager:          peerManager,
 		pexCh:                pexCh,
 		peerUpdates:          peerUpdates,
@@ -150,7 +145,7 @@ func NewReactorV2(
 // envelopes on each. In addition, it also listens for peer updates and handles
 // messages on that p2p channel accordingly. The caller must be sure to execute
 // OnStop to ensure the outbound p2p Channels are closed.
-func (r *ReactorV2) OnStart() error {
+func (r *Reactor) OnStart() error {
 	go r.processPexCh()
 	go r.processPeerUpdates()
 	return nil
@@ -158,7 +153,7 @@ func (r *ReactorV2) OnStart() error {
 
 // OnStop stops the reactor by signaling to all spawned goroutines to exit and
 // blocking until they all exit.
-func (r *ReactorV2) OnStop() {
+func (r *Reactor) OnStop() {
 	// Close closeCh to signal to all spawned goroutines to gracefully exit. All
 	// p2p Channels should execute Close().
 	close(r.closeCh)
@@ -172,7 +167,7 @@ func (r *ReactorV2) OnStop() {
 
 // processPexCh implements a blocking event loop where we listen for p2p
 // Envelope messages from the pexCh.
-func (r *ReactorV2) processPexCh() {
+func (r *Reactor) processPexCh() {
 	defer r.pexCh.Close()
 
 	for {
@@ -202,7 +197,7 @@ func (r *ReactorV2) processPexCh() {
 // processPeerUpdates initiates a blocking process where we listen for and handle
 // PeerUpdate messages. When the reactor is stopped, we will catch the signal and
 // close the p2p PeerUpdatesCh gracefully.
-func (r *ReactorV2) processPeerUpdates() {
+func (r *Reactor) processPeerUpdates() {
 	defer r.peerUpdates.Close()
 
 	for {
@@ -218,7 +213,7 @@ func (r *ReactorV2) processPeerUpdates() {
 }
 
 // handlePexMessage handles envelopes sent from peers on the PexChannel.
-func (r *ReactorV2) handlePexMessage(envelope p2p.Envelope) error {
+func (r *Reactor) handlePexMessage(envelope p2p.Envelope) error {
 	logger := r.Logger.With("peer", envelope.From)
 
 	switch msg := envelope.Message.(type) {
@@ -337,7 +332,7 @@ func (r *ReactorV2) handlePexMessage(envelope p2p.Envelope) error {
 //
 // FIXME: We may want to cache and parallelize this, but for now we'll just rely
 // on the operating system to cache it for us.
-func (r *ReactorV2) resolve(addresses []p2p.NodeAddress) []protop2p.PexAddress {
+func (r *Reactor) resolve(addresses []p2p.NodeAddress) []protop2p.PexAddress {
 	limit := len(addresses)
 	pexAddresses := make([]protop2p.PexAddress, 0, limit)
 
@@ -380,7 +375,7 @@ func (r *ReactorV2) resolve(addresses []p2p.NodeAddress) []protop2p.PexAddress {
 // handleMessage handles an Envelope sent from a peer on a specific p2p Channel.
 // It will handle errors and any possible panics gracefully. A caller can handle
 // any error returned by sending a PeerError on the respective channel.
-func (r *ReactorV2) handleMessage(chID p2p.ChannelID, envelope p2p.Envelope) (err error) {
+func (r *Reactor) handleMessage(chID p2p.ChannelID, envelope p2p.Envelope) (err error) {
 	defer func() {
 		if e := recover(); e != nil {
 			err = fmt.Errorf("panic in processing message: %v", e)
@@ -407,7 +402,7 @@ func (r *ReactorV2) handleMessage(chID p2p.ChannelID, envelope p2p.Envelope) (er
 
 // processPeerUpdate processes a PeerUpdate. For added peers, PeerStatusUp, we
 // send a request for addresses.
-func (r *ReactorV2) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
+func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
 	r.Logger.Debug("received PEX peer update", "peer", peerUpdate.NodeID, "status", peerUpdate.Status)
 
 	r.mtx.Lock()
@@ -424,7 +419,7 @@ func (r *ReactorV2) processPeerUpdate(peerUpdate p2p.PeerUpdate) {
 	}
 }
 
-func (r *ReactorV2) waitUntilNextRequest() <-chan time.Time {
+func (r *Reactor) waitUntilNextRequest() <-chan time.Time {
 	return time.After(time.Until(r.nextRequestTime))
 }
 
@@ -432,7 +427,7 @@ func (r *ReactorV2) waitUntilNextRequest() <-chan time.Time {
 // peer a request for more peer addresses. The function then moves the
 // peer into the requestsSent bucket and calculates when the next request
 // time should be
-func (r *ReactorV2) sendRequestForPeers() {
+func (r *Reactor) sendRequestForPeers() {
 	r.mtx.Lock()
 	defer r.mtx.Unlock()
 	if len(r.availablePeers) == 0 {
@@ -480,7 +475,7 @@ func (r *ReactorV2) sendRequestForPeers() {
 // new nodes will plummet to a very small number, meaning the interval expands
 // to its upper bound.
 // CONTRACT: Must use a write lock as nextRequestTime is updated
-func (r *ReactorV2) calculateNextRequestTime() {
+func (r *Reactor) calculateNextRequestTime() {
 	// check if the peer store is full. If so then there is no need
 	// to send peer requests too often
 	if ratio := r.peerManager.PeerRatio(); ratio >= 0.95 {
@@ -516,7 +511,7 @@ func (r *ReactorV2) calculateNextRequestTime() {
 	r.nextRequestTime = time.Now().Add(baseTime * time.Duration(r.discoveryRatio))
 }
 
-func (r *ReactorV2) markPeerRequest(peer types.NodeID) error {
+func (r *Reactor) markPeerRequest(peer types.NodeID) error {
 	r.mtx.Lock()
 	defer r.mtx.Unlock()
 	if lastRequestTime, ok := r.lastReceivedRequests[peer]; ok {
@@ -529,7 +524,7 @@ func (r *ReactorV2) markPeerRequest(peer types.NodeID) error {
 	return nil
 }
 
-func (r *ReactorV2) markPeerResponse(peer types.NodeID) error {
+func (r *Reactor) markPeerResponse(peer types.NodeID) error {
 	r.mtx.Lock()
 	defer r.mtx.Unlock()
 	// check if a request to this peer was sent
@@ -546,7 +541,7 @@ func (r *ReactorV2) markPeerResponse(peer types.NodeID) error {
 
 // all addresses must use a MCONN protocol for the peer to be considered part of the
 // legacy p2p pex system
-func (r *ReactorV2) isLegacyPeer(peer types.NodeID) bool {
+func (r *Reactor) isLegacyPeer(peer types.NodeID) bool {
 	for _, addr := range r.peerManager.Addresses(peer) {
 		if addr.Protocol != p2p.MConnProtocol {
 			return false
diff --git a/internal/p2p/pex/reactor_test.go b/internal/p2p/pex/reactor_test.go
index 63e479e6a3..28476e67d2 100644
--- a/internal/p2p/pex/reactor_test.go
+++ b/internal/p2p/pex/reactor_test.go
@@ -272,7 +272,7 @@ func TestReactorIntegrationWithLegacyHandleResponse(t *testing.T) {
 }
 
 type singleTestReactor struct {
-	reactor  *pex.ReactorV2
+	reactor  *pex.Reactor
 	pexInCh  chan p2p.Envelope
 	pexOutCh chan p2p.Envelope
 	pexErrCh chan p2p.PeerError
@@ -301,7 +301,7 @@ func setupSingle(t *testing.T) *singleTestReactor {
 	peerManager, err := p2p.NewPeerManager(nodeID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
 	require.NoError(t, err)
 
-	reactor := pex.NewReactorV2(log.TestingLogger(), peerManager, pexCh, peerUpdates)
+	reactor := pex.NewReactor(log.TestingLogger(), peerManager, pexCh, peerUpdates)
 	require.NoError(t, reactor.Start())
 	t.Cleanup(func() {
 		err := reactor.Stop()
@@ -327,7 +327,7 @@ type reactorTestSuite struct {
 	network *p2ptest.Network
 	logger  log.Logger
 
-	reactors    map[types.NodeID]*pex.ReactorV2
+	reactors    map[types.NodeID]*pex.Reactor
 	pexChannels map[types.NodeID]*p2p.Channel
 
 	peerChans   map[types.NodeID]chan p2p.PeerUpdate
@@ -370,7 +370,7 @@ func setupNetwork(t *testing.T, opts testOptions) *reactorTestSuite {
 	rts := &reactorTestSuite{
 		logger:      log.TestingLogger().With("testCase", t.Name()),
 		network:     p2ptest.MakeNetwork(t, networkOpts),
-		reactors:    make(map[types.NodeID]*pex.ReactorV2, realNodes),
+		reactors:    make(map[types.NodeID]*pex.Reactor, realNodes),
 		pexChannels: make(map[types.NodeID]*p2p.Channel, opts.TotalNodes),
 		peerChans:   make(map[types.NodeID]chan p2p.PeerUpdate, opts.TotalNodes),
 		peerUpdates: make(map[types.NodeID]*p2p.PeerUpdates, opts.TotalNodes),
@@ -394,7 +394,7 @@ func setupNetwork(t *testing.T, opts testOptions) *reactorTestSuite {
 		if idx < opts.MockNodes {
 			rts.mocks = append(rts.mocks, nodeID)
 		} else {
-			rts.reactors[nodeID] = pex.NewReactorV2(
+			rts.reactors[nodeID] = pex.NewReactor(
 				rts.logger.With("nodeID", nodeID),
 				rts.network.Nodes[nodeID].PeerManager,
 				rts.pexChannels[nodeID],
@@ -452,7 +452,7 @@ func (r *reactorTestSuite) addNodes(t *testing.T, nodes int) {
 		r.peerChans[nodeID] = make(chan p2p.PeerUpdate, r.opts.BufferSize)
 		r.peerUpdates[nodeID] = p2p.NewPeerUpdates(r.peerChans[nodeID], r.opts.BufferSize)
 		r.network.Nodes[nodeID].PeerManager.Register(r.peerUpdates[nodeID])
-		r.reactors[nodeID] = pex.NewReactorV2(
+		r.reactors[nodeID] = pex.NewReactor(
 			r.logger.With("nodeID", nodeID),
 			r.network.Nodes[nodeID].PeerManager,
 			r.pexChannels[nodeID],
diff --git a/node/node.go b/node/node.go
index 580121050b..a6b8d82107 100644
--- a/node/node.go
+++ b/node/node.go
@@ -352,7 +352,7 @@ func makeNode(cfg *config.Config,
 	pexCh := pex.ChannelDescriptor()
 	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
 
-	pexReactor, err = createPEXReactorV2(logger, peerManager, router)
+	pexReactor, err = createPEXReactor(logger, peerManager, router)
 	if err != nil {
 		return nil, err
 	}
@@ -466,7 +466,7 @@ func makeSeedNode(cfg *config.Config,
 	pexCh := pex.ChannelDescriptor()
 	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
 
-	pexReactor, err = createPEXReactorV2(logger, peerManager, router)
+	pexReactor, err = createPEXReactor(logger, peerManager, router)
 	if err != nil {
 		return nil, err
 	}
diff --git a/node/setup.go b/node/setup.go
index b7a2d19afa..f6b9c028de 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -440,7 +440,7 @@ func createRouter(
 	)
 }
 
-func createPEXReactorV2(
+func createPEXReactor(
 	logger log.Logger,
 	peerManager *p2p.PeerManager,
 	router *p2p.Router,
@@ -452,7 +452,7 @@ func createPEXReactorV2(
 	}
 
 	peerUpdates := peerManager.Subscribe()
-	return pex.NewReactorV2(logger, peerManager, channel, peerUpdates), nil
+	return pex.NewReactor(logger, peerManager, channel, peerUpdates), nil
 }
 
 func makeNodeInfo(
diff --git a/rpc/jsonrpc/client/integration_test.go b/rpc/jsonrpc/client/integration_test.go
index 228bbb460d..26f24d2555 100644
--- a/rpc/jsonrpc/client/integration_test.go
+++ b/rpc/jsonrpc/client/integration_test.go
@@ -1,3 +1,4 @@
+//go:build release
 // +build release
 
 // The code in here is comprehensive as an integration

From 3646b635d39cff885363b6c498b3ebe0e2f789b2 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 8 Oct 2021 12:29:20 -0400
Subject: [PATCH 33/57] p2p, types: remove legacy NetAddress type (#7084)

---
 internal/consensus/state_test.go |  23 +--
 internal/p2p/errors.go           |  10 +-
 internal/p2p/mock/peer.go        |  69 -------
 internal/p2p/mocks/peer.go       | 319 ------------------------------
 internal/p2p/netaddress.go       |  11 --
 internal/p2p/pex/errors.go       |  78 --------
 internal/p2p/router.go           |   2 -
 internal/p2p/router_test.go      |   6 +-
 internal/p2p/test_util.go        |  32 ---
 internal/p2p/transport.go        |  13 +-
 node/node.go                     |   4 +-
 types/netaddress.go              | 329 -------------------------------
 types/netaddress_test.go         | 183 -----------------
 types/node_id.go                 |   3 +-
 types/node_info.go               |  76 +++++--
 types/node_info_test.go          |  77 ++++++++
 16 files changed, 168 insertions(+), 1067 deletions(-)
 delete mode 100644 internal/p2p/mock/peer.go
 delete mode 100644 internal/p2p/mocks/peer.go
 delete mode 100644 internal/p2p/netaddress.go
 delete mode 100644 internal/p2p/pex/errors.go
 delete mode 100644 internal/p2p/test_util.go
 delete mode 100644 types/netaddress.go
 delete mode 100644 types/netaddress_test.go

diff --git a/internal/consensus/state_test.go b/internal/consensus/state_test.go
index 9b8f68a5ee..a1db8276db 100644
--- a/internal/consensus/state_test.go
+++ b/internal/consensus/state_test.go
@@ -13,7 +13,6 @@ import (
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	cstypes "github.com/tendermint/tendermint/internal/consensus/types"
-	p2pmock "github.com/tendermint/tendermint/internal/p2p/mock"
 	"github.com/tendermint/tendermint/libs/log"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
@@ -1864,7 +1863,8 @@ func TestStateOutputsBlockPartsStats(t *testing.T) {
 
 	// create dummy peer
 	cs, _ := randState(config, 1)
-	peer := p2pmock.NewPeer(nil)
+	peerID, err := types.NewNodeID("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
+	require.NoError(t, err)
 
 	// 1) new block part
 	parts := types.NewPartSetFromData(tmrand.Bytes(100), 10)
@@ -1875,26 +1875,26 @@ func TestStateOutputsBlockPartsStats(t *testing.T) {
 	}
 
 	cs.ProposalBlockParts = types.NewPartSetFromHeader(parts.Header())
-	cs.handleMsg(msgInfo{msg, peer.ID()})
+	cs.handleMsg(msgInfo{msg, peerID})
 
 	statsMessage := <-cs.statsMsgQueue
 	require.Equal(t, msg, statsMessage.Msg, "")
-	require.Equal(t, peer.ID(), statsMessage.PeerID, "")
+	require.Equal(t, peerID, statsMessage.PeerID, "")
 
 	// sending the same part from different peer
 	cs.handleMsg(msgInfo{msg, "peer2"})
 
 	// sending the part with the same height, but different round
 	msg.Round = 1
-	cs.handleMsg(msgInfo{msg, peer.ID()})
+	cs.handleMsg(msgInfo{msg, peerID})
 
 	// sending the part from the smaller height
 	msg.Height = 0
-	cs.handleMsg(msgInfo{msg, peer.ID()})
+	cs.handleMsg(msgInfo{msg, peerID})
 
 	// sending the part from the bigger height
 	msg.Height = 3
-	cs.handleMsg(msgInfo{msg, peer.ID()})
+	cs.handleMsg(msgInfo{msg, peerID})
 
 	select {
 	case <-cs.statsMsgQueue:
@@ -1909,18 +1909,19 @@ func TestStateOutputVoteStats(t *testing.T) {
 
 	cs, vss := randState(config, 2)
 	// create dummy peer
-	peer := p2pmock.NewPeer(nil)
+	peerID, err := types.NewNodeID("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")
+	require.NoError(t, err)
 
 	randBytes := tmrand.Bytes(tmhash.Size)
 
 	vote := signVote(vss[1], config, tmproto.PrecommitType, randBytes, types.PartSetHeader{})
 
 	voteMessage := &VoteMessage{vote}
-	cs.handleMsg(msgInfo{voteMessage, peer.ID()})
+	cs.handleMsg(msgInfo{voteMessage, peerID})
 
 	statsMessage := <-cs.statsMsgQueue
 	require.Equal(t, voteMessage, statsMessage.Msg, "")
-	require.Equal(t, peer.ID(), statsMessage.PeerID, "")
+	require.Equal(t, peerID, statsMessage.PeerID, "")
 
 	// sending the same part from different peer
 	cs.handleMsg(msgInfo{&VoteMessage{vote}, "peer2"})
@@ -1929,7 +1930,7 @@ func TestStateOutputVoteStats(t *testing.T) {
 	incrementHeight(vss[1])
 	vote = signVote(vss[1], config, tmproto.PrecommitType, randBytes, types.PartSetHeader{})
 
-	cs.handleMsg(msgInfo{&VoteMessage{vote}, peer.ID()})
+	cs.handleMsg(msgInfo{&VoteMessage{vote}, peerID})
 
 	select {
 	case <-cs.statsMsgQueue:
diff --git a/internal/p2p/errors.go b/internal/p2p/errors.go
index 648f2cb3a2..d4df287926 100644
--- a/internal/p2p/errors.go
+++ b/internal/p2p/errors.go
@@ -17,7 +17,7 @@ func (e ErrFilterTimeout) Error() string {
 // ErrRejected indicates that a Peer was rejected carrying additional
 // information as to the reason.
 type ErrRejected struct {
-	addr              NetAddress
+	addr              NodeAddress
 	conn              net.Conn
 	err               error
 	id                types.NodeID
@@ -30,7 +30,7 @@ type ErrRejected struct {
 }
 
 // Addr returns the NetAddress for the rejected Peer.
-func (e ErrRejected) Addr() NetAddress {
+func (e ErrRejected) Addr() NodeAddress {
 	return e.addr
 }
 
@@ -120,15 +120,15 @@ func (e ErrSwitchDuplicatePeerIP) Error() string {
 
 // ErrSwitchConnectToSelf to be raised when trying to connect to itself.
 type ErrSwitchConnectToSelf struct {
-	Addr *NetAddress
+	Addr *NodeAddress
 }
 
 func (e ErrSwitchConnectToSelf) Error() string {
-	return fmt.Sprintf("connect to self: %v", e.Addr)
+	return fmt.Sprintf("connect to self: %s", e.Addr)
 }
 
 type ErrSwitchAuthenticationFailure struct {
-	Dialed *NetAddress
+	Dialed *NodeAddress
 	Got    types.NodeID
 }
 
diff --git a/internal/p2p/mock/peer.go b/internal/p2p/mock/peer.go
deleted file mode 100644
index 366f1d7fdd..0000000000
--- a/internal/p2p/mock/peer.go
+++ /dev/null
@@ -1,69 +0,0 @@
-package mock
-
-import (
-	"net"
-
-	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/libs/service"
-	"github.com/tendermint/tendermint/types"
-)
-
-type Peer struct {
-	*service.BaseService
-	ip                   net.IP
-	id                   types.NodeID
-	addr                 *p2p.NetAddress
-	kv                   map[string]interface{}
-	Outbound, Persistent bool
-}
-
-// NewPeer creates and starts a new mock peer. If the ip
-// is nil, random routable address is used.
-func NewPeer(ip net.IP) *Peer {
-	var netAddr *p2p.NetAddress
-	if ip == nil {
-		_, netAddr = p2p.CreateRoutableAddr()
-	} else {
-		netAddr = types.NewNetAddressIPPort(ip, 26656)
-	}
-	nodeKey := types.GenNodeKey()
-	netAddr.ID = nodeKey.ID
-	mp := &Peer{
-		ip:   ip,
-		id:   nodeKey.ID,
-		addr: netAddr,
-		kv:   make(map[string]interface{}),
-	}
-	mp.BaseService = service.NewBaseService(nil, "MockPeer", mp)
-	if err := mp.Start(); err != nil {
-		panic(err)
-	}
-	return mp
-}
-
-func (mp *Peer) FlushStop()                              { mp.Stop() } //nolint:errcheck //ignore error
-func (mp *Peer) TrySend(chID byte, msgBytes []byte) bool { return true }
-func (mp *Peer) Send(chID byte, msgBytes []byte) bool    { return true }
-func (mp *Peer) NodeInfo() types.NodeInfo {
-	return types.NodeInfo{
-		NodeID:     mp.addr.ID,
-		ListenAddr: mp.addr.DialString(),
-	}
-}
-
-func (mp *Peer) ID() types.NodeID   { return mp.id }
-func (mp *Peer) IsOutbound() bool   { return mp.Outbound }
-func (mp *Peer) IsPersistent() bool { return mp.Persistent }
-func (mp *Peer) Get(key string) interface{} {
-	if value, ok := mp.kv[key]; ok {
-		return value
-	}
-	return nil
-}
-func (mp *Peer) Set(key string, value interface{}) {
-	mp.kv[key] = value
-}
-func (mp *Peer) RemoteIP() net.IP            { return mp.ip }
-func (mp *Peer) SocketAddr() *p2p.NetAddress { return mp.addr }
-func (mp *Peer) RemoteAddr() net.Addr        { return &net.TCPAddr{IP: mp.ip, Port: 8800} }
-func (mp *Peer) CloseConn() error            { return nil }
diff --git a/internal/p2p/mocks/peer.go b/internal/p2p/mocks/peer.go
deleted file mode 100644
index 3e5d20325a..0000000000
--- a/internal/p2p/mocks/peer.go
+++ /dev/null
@@ -1,319 +0,0 @@
-// Code generated by mockery. DO NOT EDIT.
-
-package mocks
-
-import (
-	log "github.com/tendermint/tendermint/libs/log"
-
-	mock "github.com/stretchr/testify/mock"
-
-	net "net"
-
-	types "github.com/tendermint/tendermint/types"
-)
-
-// Peer is an autogenerated mock type for the Peer type
-type Peer struct {
-	mock.Mock
-}
-
-// CloseConn provides a mock function with given fields:
-func (_m *Peer) CloseConn() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// FlushStop provides a mock function with given fields:
-func (_m *Peer) FlushStop() {
-	_m.Called()
-}
-
-// Get provides a mock function with given fields: _a0
-func (_m *Peer) Get(_a0 string) interface{} {
-	ret := _m.Called(_a0)
-
-	var r0 interface{}
-	if rf, ok := ret.Get(0).(func(string) interface{}); ok {
-		r0 = rf(_a0)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(interface{})
-		}
-	}
-
-	return r0
-}
-
-// ID provides a mock function with given fields:
-func (_m *Peer) ID() types.NodeID {
-	ret := _m.Called()
-
-	var r0 types.NodeID
-	if rf, ok := ret.Get(0).(func() types.NodeID); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(types.NodeID)
-	}
-
-	return r0
-}
-
-// IsOutbound provides a mock function with given fields:
-func (_m *Peer) IsOutbound() bool {
-	ret := _m.Called()
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// IsPersistent provides a mock function with given fields:
-func (_m *Peer) IsPersistent() bool {
-	ret := _m.Called()
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// IsRunning provides a mock function with given fields:
-func (_m *Peer) IsRunning() bool {
-	ret := _m.Called()
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func() bool); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// NodeInfo provides a mock function with given fields:
-func (_m *Peer) NodeInfo() types.NodeInfo {
-	ret := _m.Called()
-
-	var r0 types.NodeInfo
-	if rf, ok := ret.Get(0).(func() types.NodeInfo); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(types.NodeInfo)
-	}
-
-	return r0
-}
-
-// OnReset provides a mock function with given fields:
-func (_m *Peer) OnReset() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OnStart provides a mock function with given fields:
-func (_m *Peer) OnStart() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// OnStop provides a mock function with given fields:
-func (_m *Peer) OnStop() {
-	_m.Called()
-}
-
-// Quit provides a mock function with given fields:
-func (_m *Peer) Quit() <-chan struct{} {
-	ret := _m.Called()
-
-	var r0 <-chan struct{}
-	if rf, ok := ret.Get(0).(func() <-chan struct{}); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(<-chan struct{})
-		}
-	}
-
-	return r0
-}
-
-// RemoteAddr provides a mock function with given fields:
-func (_m *Peer) RemoteAddr() net.Addr {
-	ret := _m.Called()
-
-	var r0 net.Addr
-	if rf, ok := ret.Get(0).(func() net.Addr); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(net.Addr)
-		}
-	}
-
-	return r0
-}
-
-// RemoteIP provides a mock function with given fields:
-func (_m *Peer) RemoteIP() net.IP {
-	ret := _m.Called()
-
-	var r0 net.IP
-	if rf, ok := ret.Get(0).(func() net.IP); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(net.IP)
-		}
-	}
-
-	return r0
-}
-
-// Reset provides a mock function with given fields:
-func (_m *Peer) Reset() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Send provides a mock function with given fields: _a0, _a1
-func (_m *Peer) Send(_a0 byte, _a1 []byte) bool {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(byte, []byte) bool); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// Set provides a mock function with given fields: _a0, _a1
-func (_m *Peer) Set(_a0 string, _a1 interface{}) {
-	_m.Called(_a0, _a1)
-}
-
-// SetLogger provides a mock function with given fields: _a0
-func (_m *Peer) SetLogger(_a0 log.Logger) {
-	_m.Called(_a0)
-}
-
-// SocketAddr provides a mock function with given fields:
-func (_m *Peer) SocketAddr() *types.NetAddress {
-	ret := _m.Called()
-
-	var r0 *types.NetAddress
-	if rf, ok := ret.Get(0).(func() *types.NetAddress); ok {
-		r0 = rf()
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*types.NetAddress)
-		}
-	}
-
-	return r0
-}
-
-// Start provides a mock function with given fields:
-func (_m *Peer) Start() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// Stop provides a mock function with given fields:
-func (_m *Peer) Stop() error {
-	ret := _m.Called()
-
-	var r0 error
-	if rf, ok := ret.Get(0).(func() error); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Error(0)
-	}
-
-	return r0
-}
-
-// String provides a mock function with given fields:
-func (_m *Peer) String() string {
-	ret := _m.Called()
-
-	var r0 string
-	if rf, ok := ret.Get(0).(func() string); ok {
-		r0 = rf()
-	} else {
-		r0 = ret.Get(0).(string)
-	}
-
-	return r0
-}
-
-// TrySend provides a mock function with given fields: _a0, _a1
-func (_m *Peer) TrySend(_a0 byte, _a1 []byte) bool {
-	ret := _m.Called(_a0, _a1)
-
-	var r0 bool
-	if rf, ok := ret.Get(0).(func(byte, []byte) bool); ok {
-		r0 = rf(_a0, _a1)
-	} else {
-		r0 = ret.Get(0).(bool)
-	}
-
-	return r0
-}
-
-// Wait provides a mock function with given fields:
-func (_m *Peer) Wait() {
-	_m.Called()
-}
diff --git a/internal/p2p/netaddress.go b/internal/p2p/netaddress.go
deleted file mode 100644
index 6fce3a7696..0000000000
--- a/internal/p2p/netaddress.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Modified for Tendermint
-// Originally Copyright (c) 2013-2014 Conformal Systems LLC.
-// https://github.com/conformal/btcd/blob/master/LICENSE
-
-package p2p
-
-import (
-	"github.com/tendermint/tendermint/types"
-)
-
-type NetAddress = types.NetAddress
diff --git a/internal/p2p/pex/errors.go b/internal/p2p/pex/errors.go
deleted file mode 100644
index 4d41cce07c..0000000000
--- a/internal/p2p/pex/errors.go
+++ /dev/null
@@ -1,78 +0,0 @@
-package pex
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/tendermint/tendermint/internal/p2p"
-)
-
-type ErrAddrBookNonRoutable struct {
-	Addr *p2p.NetAddress
-}
-
-func (err ErrAddrBookNonRoutable) Error() string {
-	return fmt.Sprintf("Cannot add non-routable address %v", err.Addr)
-}
-
-type ErrAddrBookSelf struct {
-	Addr *p2p.NetAddress
-}
-
-func (err ErrAddrBookSelf) Error() string {
-	return fmt.Sprintf("Cannot add ourselves with address %v", err.Addr)
-}
-
-type ErrAddrBookPrivate struct {
-	Addr *p2p.NetAddress
-}
-
-func (err ErrAddrBookPrivate) Error() string {
-	return fmt.Sprintf("Cannot add private peer with address %v", err.Addr)
-}
-
-func (err ErrAddrBookPrivate) PrivateAddr() bool {
-	return true
-}
-
-type ErrAddrBookPrivateSrc struct {
-	Src *p2p.NetAddress
-}
-
-func (err ErrAddrBookPrivateSrc) Error() string {
-	return fmt.Sprintf("Cannot add peer coming from private peer with address %v", err.Src)
-}
-
-func (err ErrAddrBookPrivateSrc) PrivateAddr() bool {
-	return true
-}
-
-type ErrAddrBookNilAddr struct {
-	Addr *p2p.NetAddress
-	Src  *p2p.NetAddress
-}
-
-func (err ErrAddrBookNilAddr) Error() string {
-	return fmt.Sprintf("Cannot add a nil address. Got (addr, src) = (%v, %v)", err.Addr, err.Src)
-}
-
-type ErrAddrBookInvalidAddr struct {
-	Addr    *p2p.NetAddress
-	AddrErr error
-}
-
-func (err ErrAddrBookInvalidAddr) Error() string {
-	return fmt.Sprintf("Cannot add invalid address %v: %v", err.Addr, err.AddrErr)
-}
-
-// ErrAddressBanned is thrown when the address has been banned and therefore cannot be used
-type ErrAddressBanned struct {
-	Addr *p2p.NetAddress
-}
-
-func (err ErrAddressBanned) Error() string {
-	return fmt.Sprintf("Address: %v is currently banned", err.Addr)
-}
-
-// ErrUnsolicitedList is thrown when a peer provides a list of addresses that have not been asked for.
-var ErrUnsolicitedList = errors.New("unsolicited pexAddrsMessage")
diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index 8b96bc93a0..f7d012b493 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -1012,13 +1012,11 @@ func (r *Router) NodeInfo() types.NodeInfo {
 
 // OnStart implements service.Service.
 func (r *Router) OnStart() error {
-	netAddr, _ := r.nodeInfo.NetAddress()
 	r.Logger.Info(
 		"starting router",
 		"node_id", r.nodeInfo.NodeID,
 		"channels", r.nodeInfo.Channels,
 		"listen_addr", r.nodeInfo.ListenAddr,
-		"net_addr", netAddr,
 	)
 
 	go r.dialPeers()
diff --git a/internal/p2p/router_test.go b/internal/p2p/router_test.go
index 436e3f0045..c12f1a2f09 100644
--- a/internal/p2p/router_test.go
+++ b/internal/p2p/router_test.go
@@ -367,7 +367,7 @@ func TestRouter_AcceptPeers(t *testing.T) {
 			mockTransport.On("Protocols").Return([]p2p.Protocol{"mock"})
 			mockTransport.On("Close").Return(nil)
 			mockTransport.On("Accept").Once().Return(mockConnection, nil)
-			mockTransport.On("Accept").Once().Return(nil, io.EOF)
+			mockTransport.On("Accept").Maybe().Return(nil, io.EOF)
 
 			// Set up and start the router.
 			peerManager, err := p2p.NewPeerManager(selfID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
@@ -755,7 +755,7 @@ func TestRouter_EvictPeers(t *testing.T) {
 	mockTransport.On("Protocols").Return([]p2p.Protocol{"mock"})
 	mockTransport.On("Close").Return(nil)
 	mockTransport.On("Accept").Once().Return(mockConnection, nil)
-	mockTransport.On("Accept").Once().Return(nil, io.EOF)
+	mockTransport.On("Accept").Maybe().Return(nil, io.EOF)
 
 	// Set up and start the router.
 	peerManager, err := p2p.NewPeerManager(selfID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
@@ -869,7 +869,7 @@ func TestRouter_DontSendOnInvalidChannel(t *testing.T) {
 	mockTransport.On("Protocols").Return([]p2p.Protocol{"mock"})
 	mockTransport.On("Close").Return(nil)
 	mockTransport.On("Accept").Once().Return(mockConnection, nil)
-	mockTransport.On("Accept").Once().Return(nil, io.EOF)
+	mockTransport.On("Accept").Maybe().Return(nil, io.EOF)
 
 	// Set up and start the router.
 	peerManager, err := p2p.NewPeerManager(selfID, dbm.NewMemDB(), p2p.PeerManagerOptions{})
diff --git a/internal/p2p/test_util.go b/internal/p2p/test_util.go
deleted file mode 100644
index d29709a89d..0000000000
--- a/internal/p2p/test_util.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package p2p
-
-import (
-	"fmt"
-	mrand "math/rand"
-
-	tmrand "github.com/tendermint/tendermint/libs/rand"
-	"github.com/tendermint/tendermint/types"
-)
-
-//------------------------------------------------
-
-// nolint:gosec // G404: Use of weak random number generator
-func CreateRoutableAddr() (addr string, netAddr *NetAddress) {
-	for {
-		var err error
-		addr = fmt.Sprintf("%X@%v.%v.%v.%v:26656",
-			tmrand.Bytes(20),
-			mrand.Int()%256,
-			mrand.Int()%256,
-			mrand.Int()%256,
-			mrand.Int()%256)
-		netAddr, err = types.NewNetAddressString(addr)
-		if err != nil {
-			panic(err)
-		}
-		if netAddr.Routable() {
-			break
-		}
-	}
-	return
-}
diff --git a/internal/p2p/transport.go b/internal/p2p/transport.go
index 8440889d40..b49b096bbe 100644
--- a/internal/p2p/transport.go
+++ b/internal/p2p/transport.go
@@ -122,12 +122,17 @@ type Endpoint struct {
 }
 
 // NewEndpoint constructs an Endpoint from a types.NetAddress structure.
-func NewEndpoint(na *types.NetAddress) Endpoint {
+func NewEndpoint(addr string) (Endpoint, error) {
+	ip, port, err := types.ParseAddressString(addr)
+	if err != nil {
+		return Endpoint{}, err
+	}
+
 	return Endpoint{
 		Protocol: MConnProtocol,
-		IP:       na.IP,
-		Port:     na.Port,
-	}
+		IP:       ip,
+		Port:     port,
+	}, nil
 }
 
 // NodeAddress converts the endpoint into a NodeAddress for the given node ID.
diff --git a/node/node.go b/node/node.go
index a6b8d82107..87e9b0dbd8 100644
--- a/node/node.go
+++ b/node/node.go
@@ -520,11 +520,11 @@ func (n *nodeImpl) OnStart() error {
 	}
 
 	// Start the transport.
-	addr, err := types.NewNetAddressString(n.nodeKey.ID.AddressString(n.config.P2P.ListenAddress))
+	ep, err := p2p.NewEndpoint(n.nodeKey.ID.AddressString(n.config.P2P.ListenAddress))
 	if err != nil {
 		return err
 	}
-	if err := n.transport.Listen(p2p.NewEndpoint(addr)); err != nil {
+	if err := n.transport.Listen(ep); err != nil {
 		return err
 	}
 
diff --git a/types/netaddress.go b/types/netaddress.go
deleted file mode 100644
index bc074dca6e..0000000000
--- a/types/netaddress.go
+++ /dev/null
@@ -1,329 +0,0 @@
-// Modified for Tendermint
-// Originally Copyright (c) 2013-2014 Conformal Systems LLC.
-// https://github.com/conformal/btcd/blob/master/LICENSE
-
-package types
-
-import (
-	"errors"
-	"flag"
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// EmptyNetAddress defines the string representation of an empty NetAddress
-const EmptyNetAddress = "<nil-NetAddress>"
-
-// NetAddress defines information about a peer on the network
-// including its ID, IP address, and port.
-type NetAddress struct {
-	ID   NodeID `json:"id"`
-	IP   net.IP `json:"ip"`
-	Port uint16 `json:"port"`
-}
-
-// NewNetAddress returns a new NetAddress using the provided TCP
-// address. When testing, other net.Addr (except TCP) will result in
-// using 0.0.0.0:0. When normal run, other net.Addr (except TCP) will
-// panic. Panics if ID is invalid.
-// TODO: socks proxies?
-func NewNetAddress(id NodeID, addr net.Addr) *NetAddress {
-	tcpAddr, ok := addr.(*net.TCPAddr)
-	if !ok {
-		if flag.Lookup("test.v") == nil { // normal run
-			panic(fmt.Sprintf("Only TCPAddrs are supported. Got: %v", addr))
-		} else { // in testing
-			netAddr := NewNetAddressIPPort(net.IP("127.0.0.1"), 0)
-			netAddr.ID = id
-			return netAddr
-		}
-	}
-
-	if err := id.Validate(); err != nil {
-		panic(fmt.Sprintf("Invalid ID %v: %v (addr: %v)", id, err, addr))
-	}
-
-	ip := tcpAddr.IP
-	port := uint16(tcpAddr.Port)
-	na := NewNetAddressIPPort(ip, port)
-	na.ID = id
-	return na
-}
-
-// NewNetAddressIPPort returns a new NetAddress using the provided IP
-// and port number.
-func NewNetAddressIPPort(ip net.IP, port uint16) *NetAddress {
-	return &NetAddress{
-		IP:   ip,
-		Port: port,
-	}
-}
-
-// NewNetAddressString returns a new NetAddress using the provided address in
-// the form of "ID@IP:Port".
-// Also resolves the host if host is not an IP.
-// Errors are of type ErrNetAddressXxx where Xxx is in (NoID, Invalid, Lookup)
-func NewNetAddressString(addr string) (*NetAddress, error) {
-	addrWithoutProtocol := removeProtocolIfDefined(addr)
-	spl := strings.Split(addrWithoutProtocol, "@")
-	if len(spl) != 2 {
-		return nil, ErrNetAddressNoID{addr}
-	}
-
-	id, err := NewNodeID(spl[0])
-	if err != nil {
-		return nil, ErrNetAddressInvalid{addrWithoutProtocol, err}
-	}
-
-	if err := id.Validate(); err != nil {
-		return nil, ErrNetAddressInvalid{addrWithoutProtocol, err}
-	}
-
-	addrWithoutProtocol = spl[1]
-
-	// get host and port
-	host, portStr, err := net.SplitHostPort(addrWithoutProtocol)
-	if err != nil {
-		return nil, ErrNetAddressInvalid{addrWithoutProtocol, err}
-	}
-	if len(host) == 0 {
-		return nil, ErrNetAddressInvalid{
-			addrWithoutProtocol,
-			errors.New("host is empty")}
-	}
-
-	ip := net.ParseIP(host)
-	if ip == nil {
-		ips, err := net.LookupIP(host)
-		if err != nil {
-			return nil, ErrNetAddressLookup{host, err}
-		}
-		ip = ips[0]
-	}
-
-	port, err := strconv.ParseUint(portStr, 10, 16)
-	if err != nil {
-		return nil, ErrNetAddressInvalid{portStr, err}
-	}
-
-	na := NewNetAddressIPPort(ip, uint16(port))
-	na.ID = id
-	return na, nil
-}
-
-// Equals reports whether na and other are the same addresses,
-// including their ID, IP, and Port.
-func (na *NetAddress) Equals(other interface{}) bool {
-	if o, ok := other.(*NetAddress); ok {
-		return na.String() == o.String()
-	}
-	return false
-}
-
-// Same returns true is na has the same non-empty ID or DialString as other.
-func (na *NetAddress) Same(other interface{}) bool {
-	if o, ok := other.(*NetAddress); ok {
-		if na.DialString() == o.DialString() {
-			return true
-		}
-		if na.ID != "" && na.ID == o.ID {
-			return true
-		}
-	}
-	return false
-}
-
-// String representation: <ID>@<IP>:<PORT>
-func (na *NetAddress) String() string {
-	if na == nil {
-		return EmptyNetAddress
-	}
-
-	addrStr := na.DialString()
-	if na.ID != "" {
-		addrStr = na.ID.AddressString(addrStr)
-	}
-
-	return addrStr
-}
-
-func (na *NetAddress) DialString() string {
-	if na == nil {
-		return "<nil-NetAddress>"
-	}
-	return net.JoinHostPort(
-		na.IP.String(),
-		strconv.FormatUint(uint64(na.Port), 10),
-	)
-}
-
-// Dial calls net.Dial on the address.
-func (na *NetAddress) Dial() (net.Conn, error) {
-	conn, err := net.Dial("tcp", na.DialString())
-	if err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
-// DialTimeout calls net.DialTimeout on the address.
-func (na *NetAddress) DialTimeout(timeout time.Duration) (net.Conn, error) {
-	conn, err := net.DialTimeout("tcp", na.DialString(), timeout)
-	if err != nil {
-		return nil, err
-	}
-	return conn, nil
-}
-
-// Routable returns true if the address is routable.
-func (na *NetAddress) Routable() bool {
-	if err := na.Valid(); err != nil {
-		return false
-	}
-	// TODO(oga) bitcoind doesn't include RFC3849 here, but should we?
-	return !(na.RFC1918() || na.RFC3927() || na.RFC4862() ||
-		na.RFC4193() || na.RFC4843() || na.Local())
-}
-
-// For IPv4 these are either a 0 or all bits set address. For IPv6 a zero
-// address or one that matches the RFC3849 documentation address format.
-func (na *NetAddress) Valid() error {
-	if err := na.ID.Validate(); err != nil {
-		return fmt.Errorf("invalid ID: %w", err)
-	}
-
-	if na.IP == nil {
-		return errors.New("no IP")
-	}
-	if na.IP.IsUnspecified() || na.RFC3849() || na.IP.Equal(net.IPv4bcast) {
-		return errors.New("invalid IP")
-	}
-	return nil
-}
-
-// Local returns true if it is a local address.
-func (na *NetAddress) Local() bool {
-	return na.IP.IsLoopback() || zero4.Contains(na.IP)
-}
-
-// ReachabilityTo checks whenever o can be reached from na.
-func (na *NetAddress) ReachabilityTo(o *NetAddress) int {
-	const (
-		Unreachable = 0
-		Default     = iota
-		Teredo
-		Ipv6Weak
-		Ipv4
-		Ipv6Strong
-	)
-	switch {
-	case !na.Routable():
-		return Unreachable
-	case na.RFC4380():
-		switch {
-		case !o.Routable():
-			return Default
-		case o.RFC4380():
-			return Teredo
-		case o.IP.To4() != nil:
-			return Ipv4
-		default: // ipv6
-			return Ipv6Weak
-		}
-	case na.IP.To4() != nil:
-		if o.Routable() && o.IP.To4() != nil {
-			return Ipv4
-		}
-		return Default
-	default: /* ipv6 */
-		var tunneled bool
-		// Is our v6 is tunneled?
-		if o.RFC3964() || o.RFC6052() || o.RFC6145() {
-			tunneled = true
-		}
-		switch {
-		case !o.Routable():
-			return Default
-		case o.RFC4380():
-			return Teredo
-		case o.IP.To4() != nil:
-			return Ipv4
-		case tunneled:
-			// only prioritize ipv6 if we aren't tunneling it.
-			return Ipv6Weak
-		}
-		return Ipv6Strong
-	}
-}
-
-// RFC1918: IPv4 Private networks (10.0.0.0/8, 192.168.0.0/16, 172.16.0.0/12)
-// RFC3849: IPv6 Documentation address  (2001:0DB8::/32)
-// RFC3927: IPv4 Autoconfig (169.254.0.0/16)
-// RFC3964: IPv6 6to4 (2002::/16)
-// RFC4193: IPv6 unique local (FC00::/7)
-// RFC4380: IPv6 Teredo tunneling (2001::/32)
-// RFC4843: IPv6 ORCHID: (2001:10::/28)
-// RFC4862: IPv6 Autoconfig (FE80::/64)
-// RFC6052: IPv6 well known prefix (64:FF9B::/96)
-// RFC6145: IPv6 IPv4 translated address ::FFFF:0:0:0/96
-var rfc1918_10 = net.IPNet{IP: net.ParseIP("10.0.0.0"), Mask: net.CIDRMask(8, 32)}
-var rfc1918_192 = net.IPNet{IP: net.ParseIP("192.168.0.0"), Mask: net.CIDRMask(16, 32)}
-var rfc1918_172 = net.IPNet{IP: net.ParseIP("172.16.0.0"), Mask: net.CIDRMask(12, 32)}
-var rfc3849 = net.IPNet{IP: net.ParseIP("2001:0DB8::"), Mask: net.CIDRMask(32, 128)}
-var rfc3927 = net.IPNet{IP: net.ParseIP("169.254.0.0"), Mask: net.CIDRMask(16, 32)}
-var rfc3964 = net.IPNet{IP: net.ParseIP("2002::"), Mask: net.CIDRMask(16, 128)}
-var rfc4193 = net.IPNet{IP: net.ParseIP("FC00::"), Mask: net.CIDRMask(7, 128)}
-var rfc4380 = net.IPNet{IP: net.ParseIP("2001::"), Mask: net.CIDRMask(32, 128)}
-var rfc4843 = net.IPNet{IP: net.ParseIP("2001:10::"), Mask: net.CIDRMask(28, 128)}
-var rfc4862 = net.IPNet{IP: net.ParseIP("FE80::"), Mask: net.CIDRMask(64, 128)}
-var rfc6052 = net.IPNet{IP: net.ParseIP("64:FF9B::"), Mask: net.CIDRMask(96, 128)}
-var rfc6145 = net.IPNet{IP: net.ParseIP("::FFFF:0:0:0"), Mask: net.CIDRMask(96, 128)}
-var zero4 = net.IPNet{IP: net.ParseIP("0.0.0.0"), Mask: net.CIDRMask(8, 32)}
-var (
-	// onionCatNet defines the IPv6 address block used to support Tor.
-	// bitcoind encodes a .onion address as a 16 byte number by decoding the
-	// address prior to the .onion (i.e. the key hash) base32 into a ten
-	// byte number. It then stores the first 6 bytes of the address as
-	// 0xfd, 0x87, 0xd8, 0x7e, 0xeb, 0x43.
-	//
-	// This is the same range used by OnionCat, which is part part of the
-	// RFC4193 unique local IPv6 range.
-	//
-	// In summary the format is:
-	// { magic 6 bytes, 10 bytes base32 decode of key hash }
-	onionCatNet = ipNet("fd87:d87e:eb43::", 48, 128)
-)
-
-func (na *NetAddress) RFC1918() bool {
-	return rfc1918_10.Contains(na.IP) ||
-		rfc1918_192.Contains(na.IP) ||
-		rfc1918_172.Contains(na.IP)
-}
-func (na *NetAddress) RFC3849() bool     { return rfc3849.Contains(na.IP) }
-func (na *NetAddress) RFC3927() bool     { return rfc3927.Contains(na.IP) }
-func (na *NetAddress) RFC3964() bool     { return rfc3964.Contains(na.IP) }
-func (na *NetAddress) RFC4193() bool     { return rfc4193.Contains(na.IP) }
-func (na *NetAddress) RFC4380() bool     { return rfc4380.Contains(na.IP) }
-func (na *NetAddress) RFC4843() bool     { return rfc4843.Contains(na.IP) }
-func (na *NetAddress) RFC4862() bool     { return rfc4862.Contains(na.IP) }
-func (na *NetAddress) RFC6052() bool     { return rfc6052.Contains(na.IP) }
-func (na *NetAddress) RFC6145() bool     { return rfc6145.Contains(na.IP) }
-func (na *NetAddress) OnionCatTor() bool { return onionCatNet.Contains(na.IP) }
-
-func removeProtocolIfDefined(addr string) string {
-	if strings.Contains(addr, "://") {
-		return strings.Split(addr, "://")[1]
-	}
-	return addr
-
-}
-
-// ipNet returns a net.IPNet struct given the passed IP address string, number
-// of one bits to include at the start of the mask, and the total number of bits
-// for the mask.
-func ipNet(ip string, ones, bits int) net.IPNet {
-	return net.IPNet{IP: net.ParseIP(ip), Mask: net.CIDRMask(ones, bits)}
-}
diff --git a/types/netaddress_test.go b/types/netaddress_test.go
deleted file mode 100644
index 393d70e0b2..0000000000
--- a/types/netaddress_test.go
+++ /dev/null
@@ -1,183 +0,0 @@
-package types
-
-import (
-	"net"
-	"sync"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNetAddress_String(t *testing.T) {
-	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
-	require.Nil(t, err)
-
-	netAddr := NewNetAddress("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", tcpAddr)
-
-	var wg sync.WaitGroup
-
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			_ = netAddr.String()
-		}()
-	}
-
-	wg.Wait()
-
-	s := netAddr.String()
-	require.Equal(t, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", s)
-}
-
-func TestNewNetAddress(t *testing.T) {
-	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
-	require.Nil(t, err)
-
-	assert.Panics(t, func() {
-		NewNetAddress("", tcpAddr)
-	})
-
-	addr := NewNetAddress("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", tcpAddr)
-	assert.Equal(t, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", addr.String())
-
-	assert.NotPanics(t, func() {
-		NewNetAddress("", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8000})
-	}, "Calling NewNetAddress with UDPAddr should not panic in testing")
-}
-
-func TestNewNetAddressString(t *testing.T) {
-	testCases := []struct {
-		name     string
-		addr     string
-		expected string
-		correct  bool
-	}{
-		{"no node id and no protocol", "127.0.0.1:8080", "", false},
-		{"no node id w/ tcp input", "tcp://127.0.0.1:8080", "", false},
-		{"no node id w/ udp input", "udp://127.0.0.1:8080", "", false},
-
-		{
-			"no protocol",
-			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			true,
-		},
-		{
-			"tcp input",
-			"tcp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			true,
-		},
-		{
-			"udp input",
-			"udp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			true,
-		},
-		{"malformed tcp input", "tcp//deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
-		{"malformed udp input", "udp//deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
-
-		// {"127.0.0:8080", false},
-		{"invalid host", "notahost", "", false},
-		{"invalid port", "127.0.0.1:notapath", "", false},
-		{"invalid host w/ port", "notahost:8080", "", false},
-		{"just a port", "8082", "", false},
-		{"non-existent port", "127.0.0:8080000", "", false},
-
-		{"too short nodeId", "deadbeef@127.0.0.1:8080", "", false},
-		{"too short, not hex nodeId", "this-isnot-hex@127.0.0.1:8080", "", false},
-		{"not hex nodeId", "xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
-
-		{"too short nodeId w/tcp", "tcp://deadbeef@127.0.0.1:8080", "", false},
-		{"too short notHex nodeId w/tcp", "tcp://this-isnot-hex@127.0.0.1:8080", "", false},
-		{"notHex nodeId w/tcp", "tcp://xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
-		{
-			"correct nodeId w/tcp",
-			"tcp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			true,
-		},
-
-		{"no node id", "tcp://@127.0.0.1:8080", "", false},
-		{"no node id or IP", "tcp://@", "", false},
-		{"tcp no host, w/ port", "tcp://:26656", "", false},
-		{"empty", "", "", false},
-		{"node id delimiter 1", "@", "", false},
-		{"node id delimiter 2", " @", "", false},
-		{"node id delimiter 3", " @ ", "", false},
-	}
-
-	for _, tc := range testCases {
-		tc := tc
-		t.Run(tc.name, func(t *testing.T) {
-			addr, err := NewNetAddressString(tc.addr)
-			if tc.correct {
-				if assert.Nil(t, err, tc.addr) {
-					assert.Equal(t, tc.expected, addr.String())
-				}
-			} else {
-				assert.NotNil(t, err, tc.addr)
-			}
-		})
-	}
-}
-
-func TestNewNetAddressIPPort(t *testing.T) {
-	addr := NewNetAddressIPPort(net.ParseIP("127.0.0.1"), 8080)
-	assert.Equal(t, "127.0.0.1:8080", addr.String())
-}
-
-func TestNetAddressProperties(t *testing.T) {
-	// TODO add more test cases
-	testCases := []struct {
-		addr     string
-		valid    bool
-		local    bool
-		routable bool
-	}{
-		{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", true, true, false},
-		{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@ya.ru:80", true, false, true},
-	}
-
-	for _, tc := range testCases {
-		addr, err := NewNetAddressString(tc.addr)
-		require.Nil(t, err)
-
-		err = addr.Valid()
-		if tc.valid {
-			assert.NoError(t, err)
-		} else {
-			assert.Error(t, err)
-		}
-		assert.Equal(t, tc.local, addr.Local())
-		assert.Equal(t, tc.routable, addr.Routable())
-	}
-}
-
-func TestNetAddressReachabilityTo(t *testing.T) {
-	// TODO add more test cases
-	testCases := []struct {
-		addr         string
-		other        string
-		reachability int
-	}{
-		{
-			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
-			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8081",
-			0,
-		},
-		{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@ya.ru:80", "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", 1},
-	}
-
-	for _, tc := range testCases {
-		addr, err := NewNetAddressString(tc.addr)
-		require.Nil(t, err)
-
-		other, err := NewNetAddressString(tc.other)
-		require.Nil(t, err)
-
-		assert.Equal(t, tc.reachability, addr.ReachabilityTo(other))
-	}
-}
diff --git a/types/node_id.go b/types/node_id.go
index c260aa1172..a5db401598 100644
--- a/types/node_id.go
+++ b/types/node_id.go
@@ -31,8 +31,7 @@ func NewNodeID(nodeID string) (NodeID, error) {
 // IDAddressString returns id@hostPort. It strips the leading
 // protocol from protocolHostPort if it exists.
 func (id NodeID) AddressString(protocolHostPort string) string {
-	hostPort := removeProtocolIfDefined(protocolHostPort)
-	return fmt.Sprintf("%s@%s", id, hostPort)
+	return fmt.Sprintf("%s@%s", id, removeProtocolIfDefined(protocolHostPort))
 }
 
 // NodeIDFromPubKey creates a node ID from a given PubKey address.
diff --git a/types/node_info.go b/types/node_info.go
index 9dbdbf70db..902ca759bf 100644
--- a/types/node_info.go
+++ b/types/node_info.go
@@ -3,6 +3,9 @@ package types
 import (
 	"errors"
 	"fmt"
+	"net"
+	"strconv"
+	"strings"
 
 	"github.com/tendermint/tendermint/libs/bytes"
 	tmstrings "github.com/tendermint/tendermint/libs/strings"
@@ -74,17 +77,10 @@ func (info NodeInfo) ID() NodeID {
 // url-encoding), and we just need to be careful with how we handle that in our
 // clients. (e.g. off by default).
 func (info NodeInfo) Validate() error {
-
-	// ID is already validated.
-
-	// Validate ListenAddr.
-	_, err := NewNetAddressString(info.ID().AddressString(info.ListenAddr))
-	if err != nil {
+	if _, _, err := ParseAddressString(info.ID().AddressString(info.ListenAddr)); err != nil {
 		return err
 	}
 
-	// Network is validated in CompatibleWith.
-
 	// Validate Version
 	if len(info.Version) > 0 &&
 		(!tmstrings.IsASCIIText(info.Version) || tmstrings.ASCIITrim(info.Version) == "") {
@@ -163,15 +159,6 @@ OUTER_LOOP:
 	return nil
 }
 
-// NetAddress returns a NetAddress derived from the NodeInfo -
-// it includes the authenticated peer ID and the self-reported
-// ListenAddr. Note that the ListenAddr is not authenticated and
-// may not match that address actually dialed if its an outbound peer.
-func (info NodeInfo) NetAddress() (*NetAddress, error) {
-	idAddr := info.ID().AddressString(info.ListenAddr)
-	return NewNetAddressString(idAddr)
-}
-
 // AddChannel is used by the router when a channel is opened to add it to the node info
 func (info *NodeInfo) AddChannel(channel uint16) {
 	// check that the channel doesn't already exist
@@ -244,3 +231,58 @@ func NodeInfoFromProto(pb *tmp2p.NodeInfo) (NodeInfo, error) {
 
 	return dni, nil
 }
+
+// ParseAddressString reads an address string, and returns the IP
+// address and port information, returning an error for any validation
+// errors.
+func ParseAddressString(addr string) (net.IP, uint16, error) {
+	addrWithoutProtocol := removeProtocolIfDefined(addr)
+	spl := strings.Split(addrWithoutProtocol, "@")
+	if len(spl) != 2 {
+		return nil, 0, errors.New("invalid address")
+	}
+
+	id, err := NewNodeID(spl[0])
+	if err != nil {
+		return nil, 0, err
+	}
+
+	if err := id.Validate(); err != nil {
+		return nil, 0, err
+	}
+
+	addrWithoutProtocol = spl[1]
+
+	// get host and port
+	host, portStr, err := net.SplitHostPort(addrWithoutProtocol)
+	if err != nil {
+		return nil, 0, err
+	}
+	if len(host) == 0 {
+		return nil, 0, err
+	}
+
+	ip := net.ParseIP(host)
+	if ip == nil {
+		ips, err := net.LookupIP(host)
+		if err != nil {
+			return nil, 0, err
+		}
+		ip = ips[0]
+	}
+
+	port, err := strconv.ParseUint(portStr, 10, 16)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return ip, uint16(port), nil
+}
+
+func removeProtocolIfDefined(addr string) string {
+	if strings.Contains(addr, "://") {
+		return strings.Split(addr, "://")[1]
+	}
+	return addr
+
+}
diff --git a/types/node_info_test.go b/types/node_info_test.go
index 812cec1842..ff30aa30a8 100644
--- a/types/node_info_test.go
+++ b/types/node_info_test.go
@@ -173,3 +173,80 @@ func TestNodeInfoAddChannel(t *testing.T) {
 	nodeInfo.AddChannel(2)
 	require.Contains(t, nodeInfo.Channels, byte(0x02))
 }
+
+func TestParseAddressString(t *testing.T) {
+	testCases := []struct {
+		name     string
+		addr     string
+		expected string
+		correct  bool
+	}{
+		{"no node id and no protocol", "127.0.0.1:8080", "", false},
+		{"no node id w/ tcp input", "tcp://127.0.0.1:8080", "", false},
+		{"no node id w/ udp input", "udp://127.0.0.1:8080", "", false},
+
+		{
+			"no protocol",
+			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			true,
+		},
+		{
+			"tcp input",
+			"tcp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			true,
+		},
+		{
+			"udp input",
+			"udp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			true,
+		},
+		{"malformed tcp input", "tcp//deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
+		{"malformed udp input", "udp//deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
+
+		// {"127.0.0:8080", false},
+		{"invalid host", "notahost", "", false},
+		{"invalid port", "127.0.0.1:notapath", "", false},
+		{"invalid host w/ port", "notahost:8080", "", false},
+		{"just a port", "8082", "", false},
+		{"non-existent port", "127.0.0:8080000", "", false},
+
+		{"too short nodeId", "deadbeef@127.0.0.1:8080", "", false},
+		{"too short, not hex nodeId", "this-isnot-hex@127.0.0.1:8080", "", false},
+		{"not hex nodeId", "xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
+
+		{"too short nodeId w/tcp", "tcp://deadbeef@127.0.0.1:8080", "", false},
+		{"too short notHex nodeId w/tcp", "tcp://this-isnot-hex@127.0.0.1:8080", "", false},
+		{"notHex nodeId w/tcp", "tcp://xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
+		{
+			"correct nodeId w/tcp",
+			"tcp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
+			true,
+		},
+
+		{"no node id", "tcp://@127.0.0.1:8080", "", false},
+		{"no node id or IP", "tcp://@", "", false},
+		{"tcp no host, w/ port", "tcp://:26656", "", false},
+		{"empty", "", "", false},
+		{"node id delimiter 1", "@", "", false},
+		{"node id delimiter 2", " @", "", false},
+		{"node id delimiter 3", " @ ", "", false},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			addr, port, err := ParseAddressString(tc.addr)
+			if tc.correct {
+				require.Nil(t, err, tc.addr)
+				assert.Contains(t, tc.expected, addr.String())
+				assert.Contains(t, tc.expected, fmt.Sprint(port))
+			} else {
+				assert.Error(t, err, "%v", tc.addr)
+			}
+		})
+	}
+}

From befd669794af282733ecccabb50d3f18de154c61 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Sat, 9 Oct 2021 00:20:09 -0400
Subject: [PATCH 34/57] e2e: light nodes should use builtin abci app (#7095)

---
 test/e2e/pkg/testnet.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/e2e/pkg/testnet.go b/test/e2e/pkg/testnet.go
index ee6a283aa7..d0770ce8d5 100644
--- a/test/e2e/pkg/testnet.go
+++ b/test/e2e/pkg/testnet.go
@@ -187,13 +187,15 @@ func LoadTestnet(file string) (*Testnet, error) {
 			LogLevel:         manifest.LogLevel,
 			QueueType:        manifest.QueueType,
 		}
-
 		if node.StartAt == testnet.InitialHeight {
 			node.StartAt = 0 // normalize to 0 for initial nodes, since code expects this
 		}
 		if nodeManifest.Mode != "" {
 			node.Mode = Mode(nodeManifest.Mode)
 		}
+		if node.Mode == ModeLight {
+			node.ABCIProtocol = ProtocolBuiltin
+		}
 		if nodeManifest.Database != "" {
 			node.Database = nodeManifest.Database
 		}

From ded310093e0d771c9ed27f296921cb6b23d99f29 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Sat, 9 Oct 2021 11:33:54 -0400
Subject: [PATCH 35/57] lint: fix collection of stale errors (#7090)

Few things that had been annoying.
---
 .github/workflows/lint.yml        |  2 +-
 .golangci.yml                     |  4 ++--
 internal/consensus/msgs.go        |  2 +-
 internal/libs/protoio/io_test.go  |  2 +-
 internal/mempool/ids.go           | 16 +++++++---------
 internal/mempool/v0/reactor.go    |  2 +-
 internal/mempool/v1/reactor.go    |  2 +-
 internal/p2p/peermanager.go       |  6 +++---
 internal/state/state.go           |  4 ++--
 internal/state/state_test.go      |  2 +-
 internal/state/store.go           |  2 +-
 internal/state/validation_test.go |  4 ++--
 internal/statesync/reactor.go     |  2 +-
 internal/store/store.go           |  4 ++--
 libs/json/helpers_test.go         |  1 -
 node/node_test.go                 |  2 +-
 types/validation.go               | 10 +++++-----
 types/validator_set_test.go       |  2 +-
 18 files changed, 33 insertions(+), 36 deletions(-)

diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 79cb3685b7..3e257e47c5 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -23,7 +23,7 @@ jobs:
       - uses: golangci/golangci-lint-action@v2.5.2
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
-          version: v1.38
+          version: v1.42.1
           args: --timeout 10m
           github-token: ${{ secrets.github_token }}
         if: env.GIT_DIFF
diff --git a/.golangci.yml b/.golangci.yml
index b62f926e24..e0f3fe163e 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -13,12 +13,12 @@ linters:
     # - gochecknoinits
     # - gocognit
     - goconst
-    - gocritic
+    # - gocritic
     # - gocyclo
     # - godox
     - gofmt
     - goimports
-    - golint
+    - revive
     - gosec
     - gosimple
     - govet
diff --git a/internal/consensus/msgs.go b/internal/consensus/msgs.go
index 17aef9aa26..052b8f556b 100644
--- a/internal/consensus/msgs.go
+++ b/internal/consensus/msgs.go
@@ -77,7 +77,7 @@ func (m *NewRoundStepMessage) ValidateHeight(initialHeight int64) error {
 			m.LastCommitRound, initialHeight)
 	}
 	if m.Height > initialHeight && m.LastCommitRound < 0 {
-		return fmt.Errorf("LastCommitRound can only be negative for initial height %v", // nolint
+		return fmt.Errorf("LastCommitRound can only be negative for initial height %v",
 			initialHeight)
 	}
 	return nil
diff --git a/internal/libs/protoio/io_test.go b/internal/libs/protoio/io_test.go
index 2f1437c681..a84b34c002 100644
--- a/internal/libs/protoio/io_test.go
+++ b/internal/libs/protoio/io_test.go
@@ -71,7 +71,7 @@ func iotest(writer protoio.WriteCloser, reader protoio.ReadCloser) error {
 			return err
 		}
 		if n != len(bz)+visize {
-			return fmt.Errorf("WriteMsg() wrote %v bytes, expected %v", n, len(bz)+visize) // nolint
+			return fmt.Errorf("WriteMsg() wrote %v bytes, expected %v", n, len(bz)+visize)
 		}
 		lens[i] = n
 	}
diff --git a/internal/mempool/ids.go b/internal/mempool/ids.go
index 49a9ac6074..656f5b74cd 100644
--- a/internal/mempool/ids.go
+++ b/internal/mempool/ids.go
@@ -7,17 +7,15 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-// nolint: golint
-// TODO: Rename type.
-type MempoolIDs struct {
+type IDs struct {
 	mtx       tmsync.RWMutex
 	peerMap   map[types.NodeID]uint16
 	nextID    uint16              // assumes that a node will never have over 65536 active peers
 	activeIDs map[uint16]struct{} // used to check if a given peerID key is used
 }
 
-func NewMempoolIDs() *MempoolIDs {
-	return &MempoolIDs{
+func NewMempoolIDs() *IDs {
+	return &IDs{
 		peerMap: make(map[types.NodeID]uint16),
 
 		// reserve UnknownPeerID for mempoolReactor.BroadcastTx
@@ -28,7 +26,7 @@ func NewMempoolIDs() *MempoolIDs {
 
 // ReserveForPeer searches for the next unused ID and assigns it to the provided
 // peer.
-func (ids *MempoolIDs) ReserveForPeer(peerID types.NodeID) {
+func (ids *IDs) ReserveForPeer(peerID types.NodeID) {
 	ids.mtx.Lock()
 	defer ids.mtx.Unlock()
 
@@ -38,7 +36,7 @@ func (ids *MempoolIDs) ReserveForPeer(peerID types.NodeID) {
 }
 
 // Reclaim returns the ID reserved for the peer back to unused pool.
-func (ids *MempoolIDs) Reclaim(peerID types.NodeID) {
+func (ids *IDs) Reclaim(peerID types.NodeID) {
 	ids.mtx.Lock()
 	defer ids.mtx.Unlock()
 
@@ -50,7 +48,7 @@ func (ids *MempoolIDs) Reclaim(peerID types.NodeID) {
 }
 
 // GetForPeer returns an ID reserved for the peer.
-func (ids *MempoolIDs) GetForPeer(peerID types.NodeID) uint16 {
+func (ids *IDs) GetForPeer(peerID types.NodeID) uint16 {
 	ids.mtx.RLock()
 	defer ids.mtx.RUnlock()
 
@@ -59,7 +57,7 @@ func (ids *MempoolIDs) GetForPeer(peerID types.NodeID) uint16 {
 
 // nextPeerID returns the next unused peer ID to use. We assume that the mutex
 // is already held.
-func (ids *MempoolIDs) nextPeerID() uint16 {
+func (ids *IDs) nextPeerID() uint16 {
 	if len(ids.activeIDs) == MaxActiveIDs {
 		panic(fmt.Sprintf("node has maximum %d active IDs and wanted to get one more", MaxActiveIDs))
 	}
diff --git a/internal/mempool/v0/reactor.go b/internal/mempool/v0/reactor.go
index 80362a04fd..86392e96fd 100644
--- a/internal/mempool/v0/reactor.go
+++ b/internal/mempool/v0/reactor.go
@@ -39,7 +39,7 @@ type Reactor struct {
 
 	cfg     *config.MempoolConfig
 	mempool *CListMempool
-	ids     *mempool.MempoolIDs
+	ids     *mempool.IDs
 
 	// XXX: Currently, this is the only way to get information about a peer. Ideally,
 	// we rely on message-oriented communication to get necessary peer data.
diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go
index eff5b7ec05..f078083871 100644
--- a/internal/mempool/v1/reactor.go
+++ b/internal/mempool/v1/reactor.go
@@ -39,7 +39,7 @@ type Reactor struct {
 
 	cfg     *config.MempoolConfig
 	mempool *TxMempool
-	ids     *mempool.MempoolIDs
+	ids     *mempool.IDs
 
 	// XXX: Currently, this is the only way to get information about a peer. Ideally,
 	// we rely on message-oriented communication to get necessary peer data.
diff --git a/internal/p2p/peermanager.go b/internal/p2p/peermanager.go
index 1e9afb38b4..7ccc0d59c6 100644
--- a/internal/p2p/peermanager.go
+++ b/internal/p2p/peermanager.go
@@ -180,7 +180,7 @@ func (o *PeerManagerOptions) Validate() error {
 
 	if o.MaxPeers > 0 {
 		if o.MaxConnected == 0 || o.MaxConnected+o.MaxConnectedUpgrade > o.MaxPeers {
-			return fmt.Errorf("MaxConnected %v and MaxConnectedUpgrade %v can't exceed MaxPeers %v", // nolint
+			return fmt.Errorf("MaxConnected %v and MaxConnectedUpgrade %v can't exceed MaxPeers %v",
 				o.MaxConnected, o.MaxConnectedUpgrade, o.MaxPeers)
 		}
 	}
@@ -190,7 +190,7 @@ func (o *PeerManagerOptions) Validate() error {
 			return errors.New("can't set MaxRetryTime without MinRetryTime")
 		}
 		if o.MinRetryTime > o.MaxRetryTime {
-			return fmt.Errorf("MinRetryTime %v is greater than MaxRetryTime %v", // nolint
+			return fmt.Errorf("MinRetryTime %v is greater than MaxRetryTime %v",
 				o.MinRetryTime, o.MaxRetryTime)
 		}
 	}
@@ -200,7 +200,7 @@ func (o *PeerManagerOptions) Validate() error {
 			return errors.New("can't set MaxRetryTimePersistent without MinRetryTime")
 		}
 		if o.MinRetryTime > o.MaxRetryTimePersistent {
-			return fmt.Errorf("MinRetryTime %v is greater than MaxRetryTimePersistent %v", // nolint
+			return fmt.Errorf("MinRetryTime %v is greater than MaxRetryTimePersistent %v",
 				o.MinRetryTime, o.MaxRetryTimePersistent)
 		}
 	}
diff --git a/internal/state/state.go b/internal/state/state.go
index ce9990cc25..1b3c8f16e6 100644
--- a/internal/state/state.go
+++ b/internal/state/state.go
@@ -195,8 +195,8 @@ func (state *State) ToProto() (*tmstate.State, error) {
 	return sm, nil
 }
 
-// StateFromProto takes a state proto message & returns the local state type
-func StateFromProto(pb *tmstate.State) (*State, error) { //nolint:golint
+// FromProto takes a state proto message & returns the local state type
+func FromProto(pb *tmstate.State) (*State, error) {
 	if pb == nil {
 		return nil, errors.New("nil State")
 	}
diff --git a/internal/state/state_test.go b/internal/state/state_test.go
index ab73bc90c2..8c0144abde 100644
--- a/internal/state/state_test.go
+++ b/internal/state/state_test.go
@@ -1079,7 +1079,7 @@ func TestStateProto(t *testing.T) {
 			assert.NoError(t, err, tt.testName)
 		}
 
-		smt, err := sm.StateFromProto(pbs)
+		smt, err := sm.FromProto(pbs)
 		if tt.expPass2 {
 			require.NoError(t, err, tt.testName)
 			require.Equal(t, tt.state, smt, tt.testName)
diff --git a/internal/state/store.go b/internal/state/store.go
index 787b5c8ad8..aff165aa12 100644
--- a/internal/state/store.go
+++ b/internal/state/store.go
@@ -130,7 +130,7 @@ func (store dbStore) loadState(key []byte) (state State, err error) {
 		%v\n`, err))
 	}
 
-	sm, err := StateFromProto(sp)
+	sm, err := FromProto(sp)
 	if err != nil {
 		return state, err
 	}
diff --git a/internal/state/validation_test.go b/internal/state/validation_test.go
index 08c54f139d..eb0cebbb73 100644
--- a/internal/state/validation_test.go
+++ b/internal/state/validation_test.go
@@ -270,7 +270,7 @@ func TestValidateBlockEvidence(t *testing.T) {
 				A block with too much evidence fails
 			*/
 			evidence := make([]types.Evidence, 0)
-			var currentBytes int64 = 0
+			var currentBytes int64
 			// more bytes than the maximum allowed for evidence
 			for currentBytes <= maxBytesEvidence {
 				newEv := types.NewMockDuplicateVoteEvidenceWithValidator(height, time.Now(),
@@ -290,7 +290,7 @@ func TestValidateBlockEvidence(t *testing.T) {
 			A good block with several pieces of good evidence passes
 		*/
 		evidence := make([]types.Evidence, 0)
-		var currentBytes int64 = 0
+		var currentBytes int64
 		// precisely the amount of allowed evidence
 		for {
 			newEv := types.NewMockDuplicateVoteEvidenceWithValidator(height, defaultEvidenceTime,
diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index 98ace6e371..74803b3e2b 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -734,7 +734,7 @@ func (r *Reactor) handleLightBlockMessage(envelope p2p.Envelope) error {
 		}
 
 	case *ssproto.LightBlockResponse:
-		var height int64 = 0
+		var height int64
 		if msg.LightBlock != nil {
 			height = msg.LightBlock.SignedHeader.Header.Height
 		}
diff --git a/internal/store/store.go b/internal/store/store.go
index 8848b76d97..c978241ff2 100644
--- a/internal/store/store.go
+++ b/internal/store/store.go
@@ -345,7 +345,7 @@ func (bs *BlockStore) pruneRange(
 	var (
 		err         error
 		pruned      uint64
-		totalPruned uint64 = 0
+		totalPruned uint64
 	)
 
 	batch := bs.db.NewBatch()
@@ -392,7 +392,7 @@ func (bs *BlockStore) batchDelete(
 	start, end []byte,
 	preDeletionHook func(key, value []byte, batch dbm.Batch) error,
 ) (uint64, []byte, error) {
-	var pruned uint64 = 0
+	var pruned uint64
 	iter, err := bs.db.Iterator(start, end)
 	if err != nil {
 		return pruned, start, err
diff --git a/libs/json/helpers_test.go b/libs/json/helpers_test.go
index a87bc51f15..ccb3c00388 100644
--- a/libs/json/helpers_test.go
+++ b/libs/json/helpers_test.go
@@ -61,7 +61,6 @@ func (c CustomValue) MarshalJSON() ([]byte, error) {
 }
 
 func (c CustomValue) UnmarshalJSON(bz []byte) error {
-	c.Value = "custom"
 	return nil
 }
 
diff --git a/node/node_test.go b/node/node_test.go
index 30e7a8f13b..61fd3fa21f 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -249,7 +249,7 @@ func TestCreateProposalBlock(t *testing.T) {
 
 	// fill the evidence pool with more evidence
 	// than can fit in a block
-	var currentBytes int64 = 0
+	var currentBytes int64
 	for currentBytes <= maxEvidenceBytes {
 		ev := types.NewMockDuplicateVoteEvidenceWithValidator(height, time.Now(), privVals[0], "test-chain")
 		currentBytes += int64(len(ev.Bytes()))
diff --git a/types/validation.go b/types/validation.go
index 1bf0265db8..e8f53f2a01 100644
--- a/types/validation.go
+++ b/types/validation.go
@@ -162,9 +162,9 @@ func verifyCommitBatch(
 	var (
 		val                *Validator
 		valIdx             int32
-		seenVals                 = make(map[int32]int, len(commit.Signatures))
-		batchSigIdxs             = make([]int, 0, len(commit.Signatures))
-		talliedVotingPower int64 = 0
+		talliedVotingPower int64
+		seenVals           = make(map[int32]int, len(commit.Signatures))
+		batchSigIdxs       = make([]int, 0, len(commit.Signatures))
 	)
 	// attempt to create a batch verifier
 	bv, ok := batch.CreateBatchVerifier(vals.GetProposer().PubKey)
@@ -275,9 +275,9 @@ func verifyCommitSingle(
 	var (
 		val                *Validator
 		valIdx             int32
-		seenVals                 = make(map[int32]int, len(commit.Signatures))
-		talliedVotingPower int64 = 0
+		talliedVotingPower int64
 		voteSignBytes      []byte
+		seenVals           = make(map[int32]int, len(commit.Signatures))
 	)
 	for idx, commitSig := range commit.Signatures {
 		if ignoreSig(commitSig) {
diff --git a/types/validator_set_test.go b/types/validator_set_test.go
index a691213443..87008bb1c4 100644
--- a/types/validator_set_test.go
+++ b/types/validator_set_test.go
@@ -508,7 +508,7 @@ func TestAveragingInIncrementProposerPriority(t *testing.T) {
 				{Address: []byte("c"), ProposerPriority: 1}}},
 			// this should average twice but the average should be 0 after the first iteration
 			// (voting power is 0 -> no changes)
-			11, 1 / 3},
+			11, 0},
 		2: {ValidatorSet{
 			Validators: []*Validator{
 				{Address: []byte("a"), ProposerPriority: 100},

From 48295955edfd50b24fef42f1e96f7c54333c1ca8 Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Mon, 11 Oct 2021 16:21:45 -0700
Subject: [PATCH 36/57] light: Update links in package docs. (#7099)

Fixes #7098. The light client documentation moved to the spec repository.

I was not able to figure out what happened to light-client-protocol.md, it was removed in #5252 but no corresponding file exists in the spec repository. Since the spec also discusses the protocol, this change simply links to the spec and removes the non-functional reference.

Alternatively we could link to the top-level [light client doc](https://docs.tendermint.com/master/tendermint-core/light-client.html) if you think that's better.
---
 light/doc.go | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/light/doc.go b/light/doc.go
index 700bbeb6cf..c30c68eb04 100644
--- a/light/doc.go
+++ b/light/doc.go
@@ -94,7 +94,7 @@ Check out other examples in example_test.go
 ## 2. Pure functions to verify a new header (see verifier.go)
 
 Verify function verifies a new header against some trusted header. See
-https://github.com/tendermint/spec/blob/master/spec/consensus/light-client/verification.md
+https://github.com/tendermint/spec/blob/master/spec/light-client/verification/README.md
 for details.
 
 There are two methods of verification: sequential and bisection
@@ -118,10 +118,7 @@ as a wrapper, which verifies all the headers, using a light client connected to
 some other node.
 
 See
-https://docs.tendermint.com/master/tendermint-core/light-client-protocol.html
-for usage example.
-Or see
-https://github.com/tendermint/spec/tree/master/spec/consensus/light-client
-for the full spec
+https://github.com/tendermint/spec/tree/master/spec/light-client
+for the light client specification.
 */
 package light

From 34a3fcd8fcfef1118b2f12113fb04e6d50d34f15 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 12 Oct 2021 11:29:31 -0400
Subject: [PATCH 37/57] Revert "abci: change client to use multi-reader mutexes
 (#6306)" (#7106)

This reverts commit 1c4dbe30d40bb4c1dc59a2247d5113b78702a014.
---
 abci/client/client.go                |  8 ++++----
 abci/client/creators.go              |  2 +-
 abci/client/grpc_client.go           |  8 ++++----
 abci/client/local_client.go          | 26 ++++++++++++--------------
 abci/client/socket_client.go         |  8 ++++----
 internal/consensus/byzantine_test.go |  2 +-
 internal/consensus/common_test.go    |  2 +-
 internal/consensus/reactor_test.go   |  2 +-
 8 files changed, 28 insertions(+), 30 deletions(-)

diff --git a/abci/client/client.go b/abci/client/client.go
index 93f8b92934..a38c7f81b5 100644
--- a/abci/client/client.go
+++ b/abci/client/client.go
@@ -87,7 +87,7 @@ type ReqRes struct {
 	*sync.WaitGroup
 	*types.Response // Not set atomically, so be sure to use WaitGroup.
 
-	mtx  tmsync.RWMutex
+	mtx  tmsync.Mutex
 	done bool                  // Gets set to true once *after* WaitGroup.Done().
 	cb   func(*types.Response) // A single callback that may be set.
 }
@@ -137,16 +137,16 @@ func (r *ReqRes) InvokeCallback() {
 //
 // ref: https://github.com/tendermint/tendermint/issues/5439
 func (r *ReqRes) GetCallback() func(*types.Response) {
-	r.mtx.RLock()
-	defer r.mtx.RUnlock()
+	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()
 	r.done = true
+	r.mtx.Unlock()
 }
 
 func waitGroup1() (wg *sync.WaitGroup) {
diff --git a/abci/client/creators.go b/abci/client/creators.go
index 5a71becafe..e17b15eca4 100644
--- a/abci/client/creators.go
+++ b/abci/client/creators.go
@@ -13,7 +13,7 @@ type Creator func() (Client, error)
 // NewLocalCreator returns a Creator for the given app,
 // which will be running locally.
 func NewLocalCreator(app types.Application) Creator {
-	mtx := new(tmsync.RWMutex)
+	mtx := new(tmsync.Mutex)
 
 	return func() (Client, error) {
 		return NewLocalClient(mtx, app), nil
diff --git a/abci/client/grpc_client.go b/abci/client/grpc_client.go
index 2bfa047bd7..f1123fab5f 100644
--- a/abci/client/grpc_client.go
+++ b/abci/client/grpc_client.go
@@ -24,7 +24,7 @@ type grpcClient struct {
 	conn     *grpc.ClientConn
 	chReqRes chan *ReqRes // dispatches "async" responses to callbacks *in order*, needed by mempool
 
-	mtx   tmsync.RWMutex
+	mtx   tmsync.Mutex
 	addr  string
 	err   error
 	resCb func(*types.Request, *types.Response) // listens to all callbacks
@@ -149,8 +149,8 @@ func (cli *grpcClient) StopForError(err error) {
 }
 
 func (cli *grpcClient) Error() error {
-	cli.mtx.RLock()
-	defer cli.mtx.RUnlock()
+	cli.mtx.Lock()
+	defer cli.mtx.Unlock()
 	return cli.err
 }
 
@@ -158,8 +158,8 @@ func (cli *grpcClient) Error() error {
 // NOTE: callback may get internally generated flush responses.
 func (cli *grpcClient) SetResponseCallback(resCb Callback) {
 	cli.mtx.Lock()
-	defer cli.mtx.Unlock()
 	cli.resCb = resCb
+	cli.mtx.Unlock()
 }
 
 //----------------------------------------
diff --git a/abci/client/local_client.go b/abci/client/local_client.go
index 06ff8171c2..701108a3c8 100644
--- a/abci/client/local_client.go
+++ b/abci/client/local_client.go
@@ -15,7 +15,7 @@ import (
 type localClient struct {
 	service.BaseService
 
-	mtx *tmsync.RWMutex
+	mtx *tmsync.Mutex
 	types.Application
 	Callback
 }
@@ -26,24 +26,22 @@ var _ Client = (*localClient)(nil)
 // methods of the given app.
 //
 // Both Async and Sync methods ignore the given context.Context parameter.
-func NewLocalClient(mtx *tmsync.RWMutex, app types.Application) Client {
+func NewLocalClient(mtx *tmsync.Mutex, app types.Application) Client {
 	if mtx == nil {
-		mtx = &tmsync.RWMutex{}
+		mtx = new(tmsync.Mutex)
 	}
-
 	cli := &localClient{
 		mtx:         mtx,
 		Application: app,
 	}
-
 	cli.BaseService = *service.NewBaseService(nil, "localClient", cli)
 	return cli
 }
 
 func (app *localClient) SetResponseCallback(cb Callback) {
 	app.mtx.Lock()
-	defer app.mtx.Unlock()
 	app.Callback = cb
+	app.mtx.Unlock()
 }
 
 // TODO: change types.Application to include Error()?
@@ -67,8 +65,8 @@ func (app *localClient) EchoAsync(ctx context.Context, msg string) (*ReqRes, err
 }
 
 func (app *localClient) InfoAsync(ctx context.Context, req types.RequestInfo) (*ReqRes, error) {
-	app.mtx.RLock()
-	defer app.mtx.RUnlock()
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
 
 	res := app.Application.Info(req)
 	return app.callback(
@@ -100,8 +98,8 @@ func (app *localClient) CheckTxAsync(ctx context.Context, req types.RequestCheck
 }
 
 func (app *localClient) QueryAsync(ctx context.Context, req types.RequestQuery) (*ReqRes, error) {
-	app.mtx.RLock()
-	defer app.mtx.RUnlock()
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
 
 	res := app.Application.Query(req)
 	return app.callback(
@@ -215,8 +213,8 @@ func (app *localClient) EchoSync(ctx context.Context, msg string) (*types.Respon
 }
 
 func (app *localClient) InfoSync(ctx context.Context, req types.RequestInfo) (*types.ResponseInfo, error) {
-	app.mtx.RLock()
-	defer app.mtx.RUnlock()
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
 
 	res := app.Application.Info(req)
 	return &res, nil
@@ -249,8 +247,8 @@ func (app *localClient) QuerySync(
 	ctx context.Context,
 	req types.RequestQuery,
 ) (*types.ResponseQuery, error) {
-	app.mtx.RLock()
-	defer app.mtx.RUnlock()
+	app.mtx.Lock()
+	defer app.mtx.Unlock()
 
 	res := app.Application.Query(req)
 	return &res, nil
diff --git a/abci/client/socket_client.go b/abci/client/socket_client.go
index 8a4598fe5d..726c554d4d 100644
--- a/abci/client/socket_client.go
+++ b/abci/client/socket_client.go
@@ -39,7 +39,7 @@ type socketClient struct {
 
 	reqQueue chan *reqResWithContext
 
-	mtx     tmsync.RWMutex
+	mtx     tmsync.Mutex
 	err     error
 	reqSent *list.List                            // list of requests sent, waiting for response
 	resCb   func(*types.Request, *types.Response) // called on all requests, if set.
@@ -102,8 +102,8 @@ func (cli *socketClient) OnStop() {
 
 // Error returns an error if the client was stopped abruptly.
 func (cli *socketClient) Error() error {
-	cli.mtx.RLock()
-	defer cli.mtx.RUnlock()
+	cli.mtx.Lock()
+	defer cli.mtx.Unlock()
 	return cli.err
 }
 
@@ -113,8 +113,8 @@ func (cli *socketClient) Error() error {
 // NOTE: callback may get internally generated flush responses.
 func (cli *socketClient) SetResponseCallback(resCb Callback) {
 	cli.mtx.Lock()
-	defer cli.mtx.Unlock()
 	cli.resCb = resCb
+	cli.mtx.Unlock()
 }
 
 //----------------------------------------
diff --git a/internal/consensus/byzantine_test.go b/internal/consensus/byzantine_test.go
index 81a4f8be80..a826ef79bc 100644
--- a/internal/consensus/byzantine_test.go
+++ b/internal/consensus/byzantine_test.go
@@ -62,7 +62,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 			blockStore := store.NewBlockStore(blockDB)
 
 			// one for mempool, one for consensus
-			mtx := new(tmsync.RWMutex)
+			mtx := new(tmsync.Mutex)
 			proxyAppConnMem := abciclient.NewLocalClient(mtx, app)
 			proxyAppConnCon := abciclient.NewLocalClient(mtx, app)
 
diff --git a/internal/consensus/common_test.go b/internal/consensus/common_test.go
index 5251b0fdba..8b54f6026d 100644
--- a/internal/consensus/common_test.go
+++ b/internal/consensus/common_test.go
@@ -407,7 +407,7 @@ func newStateWithConfigAndBlockStore(
 	blockStore *store.BlockStore,
 ) *State {
 	// one for mempool, one for consensus
-	mtx := new(tmsync.RWMutex)
+	mtx := new(tmsync.Mutex)
 	proxyAppConnMem := abciclient.NewLocalClient(mtx, app)
 	proxyAppConnCon := abciclient.NewLocalClient(mtx, app)
 
diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go
index baffbac30d..e536906a98 100644
--- a/internal/consensus/reactor_test.go
+++ b/internal/consensus/reactor_test.go
@@ -346,7 +346,7 @@ func TestReactorWithEvidence(t *testing.T) {
 		blockStore := store.NewBlockStore(blockDB)
 
 		// one for mempool, one for consensus
-		mtx := new(tmsync.RWMutex)
+		mtx := new(tmsync.Mutex)
 		proxyAppConnMem := abciclient.NewLocalClient(mtx, app)
 		proxyAppConnCon := abciclient.NewLocalClient(mtx, app)
 

From d837432681eb835cee35b2aa477b244eb5254666 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 12 Oct 2021 12:28:10 -0400
Subject: [PATCH 38/57] ci: use run-multiple.sh for e2e pr tests (#7111)

* ci: use run-multiple.sh for e2e pr tests

* fix labeling

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

Co-authored-by: M. J. Fromberger <michael.j.fromberger@gmail.com>

Co-authored-by: M. J. Fromberger <michael.j.fromberger@gmail.com>
---
 .github/workflows/e2e-nightly-35x.yml    | 6 +++---
 .github/workflows/e2e-nightly-master.yml | 6 +++---
 .github/workflows/e2e.yml                | 6 +-----
 3 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/e2e-nightly-35x.yml b/.github/workflows/e2e-nightly-35x.yml
index 13d4b3dc83..b3acdf62be 100644
--- a/.github/workflows/e2e-nightly-35x.yml
+++ b/.github/workflows/e2e-nightly-35x.yml
@@ -10,7 +10,7 @@ on:
     - cron: '0 2 * * *'
 
 jobs:
-  e2e-nightly-test-2:
+  e2e-nightly-test:
     # Run parallel jobs for the listed testnet groups (must match the
     # ./build/generator -g flag)
     strategy:
@@ -44,7 +44,7 @@ jobs:
         run: ./run-multiple.sh networks/nightly/${{ matrix.p2p }}/*-group${{ matrix.group }}-*.toml
 
   e2e-nightly-fail-2:
-    needs: e2e-nightly-test-2
+    needs: e2e-nightly-test
     if: ${{ failure() }}
     runs-on: ubuntu-latest
     steps:
@@ -60,7 +60,7 @@ jobs:
           SLACK_FOOTER: ''
 
   e2e-nightly-success: # may turn this off once they seem to pass consistently
-    needs: e2e-nightly-test-2
+    needs: e2e-nightly-test
     if: ${{ success() }}
     runs-on: ubuntu-latest
     steps:
diff --git a/.github/workflows/e2e-nightly-master.yml b/.github/workflows/e2e-nightly-master.yml
index 28f8b3e4be..da8b07d70e 100644
--- a/.github/workflows/e2e-nightly-master.yml
+++ b/.github/workflows/e2e-nightly-master.yml
@@ -10,7 +10,7 @@ on:
     - cron: '0 2 * * *'
 
 jobs:
-  e2e-nightly-test-2:
+  e2e-nightly-test:
     # Run parallel jobs for the listed testnet groups (must match the
     # ./build/generator -g flag)
     strategy:
@@ -41,7 +41,7 @@ jobs:
         run: ./run-multiple.sh networks/nightly/*-group${{ matrix.group }}-*.toml
 
   e2e-nightly-fail-2:
-    needs: e2e-nightly-test-2
+    needs: e2e-nightly-test
     if: ${{ failure() }}
     runs-on: ubuntu-latest
     steps:
@@ -57,7 +57,7 @@ jobs:
           SLACK_FOOTER: ''
 
   e2e-nightly-success: # may turn this off once they seem to pass consistently
-    needs: e2e-nightly-test-2
+    needs: e2e-nightly-test
     if: ${{ success() }}
     runs-on: ubuntu-latest
     steps:
diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml
index a0f18cd1b9..134ae979c9 100644
--- a/.github/workflows/e2e.yml
+++ b/.github/workflows/e2e.yml
@@ -33,10 +33,6 @@ jobs:
 
       - name: Run CI testnet
         working-directory: test/e2e
-        run: ./build/runner -f networks/ci.toml
+        run: ./run-multiple.sh networks/ci.toml
         if: "env.GIT_DIFF != ''"
 
-      - name: Emit logs on failure
-        if: ${{ failure() }}
-        working-directory: test/e2e
-        run: ./build/runner -f networks/ci.toml logs

From 05245586967e3064fffcecc75d4035e4249d792e Mon Sep 17 00:00:00 2001
From: lklimek <842586+lklimek@users.noreply.github.com>
Date: Tue, 12 Oct 2021 22:22:57 +0200
Subject: [PATCH 39/57] refactor: assignment copies lock value (#7108)

Co-authored-by: M. J. Fromberger <fromberger@interchain.io>
---
 CHANGELOG_PENDING.md   |  2 ++
 libs/bits/bit_array.go | 30 ++++++++++++++++++++----------
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md
index fafb9cea73..0f8ba5ea7c 100644
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -36,3 +36,5 @@ Special thanks to external contributors on this release:
 ### IMPROVEMENTS
 
 ### BUG FIXES
+
+- fix: assignment copies lock value in `BitArray.UnmarshalJSON()` (@lklimek)
diff --git a/libs/bits/bit_array.go b/libs/bits/bit_array.go
index b78fafddd6..a0258521c4 100644
--- a/libs/bits/bit_array.go
+++ b/libs/bits/bit_array.go
@@ -30,9 +30,21 @@ func NewBitArray(bits int) *BitArray {
 	if bits <= 0 {
 		return nil
 	}
-	return &BitArray{
-		Bits:  bits,
-		Elems: make([]uint64, numElems(bits)),
+	bA := &BitArray{}
+	bA.reset(bits)
+	return bA
+}
+
+// reset changes size of BitArray to `bits` and re-allocates (zeroed) data buffer
+func (bA *BitArray) reset(bits int) {
+	bA.mtx.Lock()
+	defer bA.mtx.Unlock()
+
+	bA.Bits = bits
+	if bits == 0 {
+		bA.Elems = nil
+	} else {
+		bA.Elems = make([]uint64, numElems(bits))
 	}
 }
 
@@ -399,8 +411,7 @@ func (bA *BitArray) UnmarshalJSON(bz []byte) error {
 	if b == "null" {
 		// This is required e.g. for encoding/json when decoding
 		// into a pointer with pre-allocated BitArray.
-		bA.Bits = 0
-		bA.Elems = nil
+		bA.reset(0)
 		return nil
 	}
 
@@ -410,16 +421,15 @@ func (bA *BitArray) UnmarshalJSON(bz []byte) error {
 		return fmt.Errorf("bitArray in JSON should be a string of format %q but got %s", bitArrayJSONRegexp.String(), b)
 	}
 	bits := match[1]
-
-	// Construct new BitArray and copy over.
 	numBits := len(bits)
-	bA2 := NewBitArray(numBits)
+
+	bA.reset(numBits)
 	for i := 0; i < numBits; i++ {
 		if bits[i] == 'x' {
-			bA2.SetIndex(i, true)
+			bA.SetIndex(i, true)
 		}
 	}
-	*bA = *bA2 //nolint:govet
+
 	return nil
 }
 

From 52ed9944162012a5ad44fa611f263545757d6021 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 12 Oct 2021 16:49:45 -0400
Subject: [PATCH 40/57] test: cleanup rpc/client and node test fixtures (#7112)

---
 node/node.go                           |   14 +-
 node/node_test.go                      |   94 +-
 rpc/client/event_test.go               |  200 +---
 rpc/client/examples_test.go            |  112 +-
 rpc/client/http/http.go                |   11 +-
 rpc/client/main_test.go                |    7 +-
 rpc/client/rpc_test.go                 | 1319 ++++++++++++------------
 rpc/jsonrpc/client/http_json_client.go |    3 +-
 8 files changed, 828 insertions(+), 932 deletions(-)

diff --git a/node/node.go b/node/node.go
index 87e9b0dbd8..6092f4c43c 100644
--- a/node/node.go
+++ b/node/node.go
@@ -641,12 +641,16 @@ func (n *nodeImpl) OnStop() {
 
 	n.Logger.Info("Stopping Node")
 
-	// first stop the non-reactor services
-	if err := n.eventBus.Stop(); err != nil {
-		n.Logger.Error("Error closing eventBus", "err", err)
+	if n.eventBus != nil {
+		// first stop the non-reactor services
+		if err := n.eventBus.Stop(); err != nil {
+			n.Logger.Error("Error closing eventBus", "err", err)
+		}
 	}
-	if err := n.indexerService.Stop(); err != nil {
-		n.Logger.Error("Error closing indexerService", "err", err)
+	if n.indexerService != nil {
+		if err := n.indexerService.Stop(); err != nil {
+			n.Logger.Error("Error closing indexerService", "err", err)
+		}
 	}
 
 	if n.config.Mode != config.ModeSeed {
diff --git a/node/node_test.go b/node/node_test.go
index 61fd3fa21f..d5ea39aa67 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -31,6 +31,7 @@ import (
 	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
+	"github.com/tendermint/tendermint/libs/service"
 	tmtime "github.com/tendermint/tendermint/libs/time"
 	"github.com/tendermint/tendermint/privval"
 	"github.com/tendermint/tendermint/types"
@@ -46,11 +47,21 @@ func TestNodeStartStop(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, ns.Start())
 
+	t.Cleanup(func() {
+		if ns.IsRunning() {
+			assert.NoError(t, ns.Stop())
+			ns.Wait()
+		}
+	})
+
 	n, ok := ns.(*nodeImpl)
 	require.True(t, ok)
 
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	// wait for the node to produce a block
-	blocksSub, err := n.EventBus().Subscribe(context.Background(), "node_test", types.EventQueryNewBlock)
+	blocksSub, err := n.EventBus().Subscribe(ctx, "node_test", types.EventQueryNewBlock)
 	require.NoError(t, err)
 	select {
 	case <-blocksSub.Out():
@@ -87,6 +98,14 @@ func getTestNode(t *testing.T, conf *config.Config, logger log.Logger) *nodeImpl
 
 	n, ok := ns.(*nodeImpl)
 	require.True(t, ok)
+
+	t.Cleanup(func() {
+		if ns.IsRunning() {
+			assert.NoError(t, ns.Stop())
+			ns.Wait()
+		}
+	})
+
 	return n
 }
 
@@ -100,7 +119,6 @@ func TestNodeDelayedStart(t *testing.T) {
 	n.GenesisDoc().GenesisTime = now.Add(2 * time.Second)
 
 	require.NoError(t, n.Start())
-	defer n.Stop() //nolint:errcheck // ignore for tests
 
 	startTime := tmtime.Now()
 	assert.Equal(t, true, startTime.After(n.GenesisDoc().GenesisTime))
@@ -165,8 +183,13 @@ func TestPrivValidatorListenAddrNoProtocol(t *testing.T) {
 	defer os.RemoveAll(cfg.RootDir)
 	cfg.PrivValidator.ListenAddr = addrNoPrefix
 
-	_, err := newDefaultNode(cfg, log.TestingLogger())
+	n, err := newDefaultNode(cfg, log.TestingLogger())
 	assert.Error(t, err)
+
+	if n != nil && n.IsRunning() {
+		assert.NoError(t, n.Stop())
+		n.Wait()
+	}
 }
 
 func TestNodeSetPrivValIPC(t *testing.T) {
@@ -211,6 +234,9 @@ func testFreeAddr(t *testing.T) string {
 // create a proposal block using real and full
 // mempool and evidence pool and validate it.
 func TestCreateProposalBlock(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	cfg := config.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(cfg.RootDir)
 	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
@@ -222,7 +248,7 @@ func TestCreateProposalBlock(t *testing.T) {
 	logger := log.TestingLogger()
 
 	const height int64 = 1
-	state, stateDB, privVals := state(1, height)
+	state, stateDB, privVals := state(t, 1, height)
 	stateStore := sm.NewStore(stateDB)
 	maxBytes := 16384
 	const partSize uint32 = 256
@@ -266,7 +292,7 @@ func TestCreateProposalBlock(t *testing.T) {
 	txLength := 100
 	for i := 0; i <= maxBytes/txLength; i++ {
 		tx := tmrand.Bytes(txLength)
-		err := mp.CheckTx(context.Background(), tx, nil, mempool.TxInfo{})
+		err := mp.CheckTx(ctx, tx, nil, mempool.TxInfo{})
 		assert.NoError(t, err)
 	}
 
@@ -303,6 +329,9 @@ func TestCreateProposalBlock(t *testing.T) {
 }
 
 func TestMaxTxsProposalBlockSize(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	cfg := config.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(cfg.RootDir)
 	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
@@ -314,7 +343,7 @@ func TestMaxTxsProposalBlockSize(t *testing.T) {
 	logger := log.TestingLogger()
 
 	const height int64 = 1
-	state, stateDB, _ := state(1, height)
+	state, stateDB, _ := state(t, 1, height)
 	stateStore := sm.NewStore(stateDB)
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
 	const maxBytes int64 = 16384
@@ -336,7 +365,7 @@ func TestMaxTxsProposalBlockSize(t *testing.T) {
 	// fill the mempool with one txs just below the maximum size
 	txLength := int(types.MaxDataBytesNoEvidence(maxBytes, 1))
 	tx := tmrand.Bytes(txLength - 4) // to account for the varint
-	err = mp.CheckTx(context.Background(), tx, nil, mempool.TxInfo{})
+	err = mp.CheckTx(ctx, tx, nil, mempool.TxInfo{})
 	assert.NoError(t, err)
 
 	blockExec := sm.NewBlockExecutor(
@@ -365,6 +394,9 @@ func TestMaxTxsProposalBlockSize(t *testing.T) {
 }
 
 func TestMaxProposalBlockSize(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	cfg := config.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(cfg.RootDir)
 	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
@@ -375,7 +407,7 @@ func TestMaxProposalBlockSize(t *testing.T) {
 
 	logger := log.TestingLogger()
 
-	state, stateDB, _ := state(types.MaxVotesCount, int64(1))
+	state, stateDB, _ := state(t, types.MaxVotesCount, int64(1))
 	stateStore := sm.NewStore(stateDB)
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
 	const maxBytes int64 = 1024 * 1024 * 2
@@ -402,7 +434,7 @@ func TestMaxProposalBlockSize(t *testing.T) {
 	// At the end of the test, only the single big tx should be added
 	for i := 0; i < 10; i++ {
 		tx := tmrand.Bytes(10)
-		err = mp.CheckTx(context.Background(), tx, nil, mempool.TxInfo{})
+		err = mp.CheckTx(ctx, tx, nil, mempool.TxInfo{})
 		assert.NoError(t, err)
 	}
 
@@ -493,14 +525,17 @@ func TestNodeNewSeedNode(t *testing.T) {
 		defaultGenesisDocProviderFunc(cfg),
 		log.TestingLogger(),
 	)
+
 	require.NoError(t, err)
 	n, ok := ns.(*nodeImpl)
 	require.True(t, ok)
 
 	err = n.Start()
 	require.NoError(t, err)
-
 	assert.True(t, n.pexReactor.IsRunning())
+
+	require.NoError(t, n.Stop())
+
 }
 
 func TestNodeSetEventSink(t *testing.T) {
@@ -511,7 +546,7 @@ func TestNodeSetEventSink(t *testing.T) {
 	setupTest := func(t *testing.T, conf *config.Config) []indexer.EventSink {
 		eventBus, err := createAndStartEventBus(logger)
 		require.NoError(t, err)
-
+		t.Cleanup(func() { require.NoError(t, eventBus.Stop()) })
 		genDoc, err := types.GenesisDocFromFile(cfg.GenesisFile())
 		require.NoError(t, err)
 
@@ -521,6 +556,22 @@ func TestNodeSetEventSink(t *testing.T) {
 		t.Cleanup(func() { require.NoError(t, indexService.Stop()) })
 		return eventSinks
 	}
+	cleanup := func(ns service.Service) func() {
+		return func() {
+			n, ok := ns.(*nodeImpl)
+			if !ok {
+				return
+			}
+			if n == nil {
+				return
+			}
+			if !n.IsRunning() {
+				return
+			}
+			assert.NoError(t, n.Stop())
+			n.Wait()
+		}
+	}
 
 	eventSinks := setupTest(t, cfg)
 	assert.Equal(t, 1, len(eventSinks))
@@ -542,6 +593,7 @@ func TestNodeSetEventSink(t *testing.T) {
 	ns, err := newDefaultNode(cfg, logger)
 	assert.Nil(t, ns)
 	assert.Equal(t, errors.New("unsupported event sink type"), err)
+	t.Cleanup(cleanup(ns))
 
 	cfg.TxIndex.Indexer = []string{}
 	eventSinks = setupTest(t, cfg)
@@ -553,6 +605,7 @@ func TestNodeSetEventSink(t *testing.T) {
 	ns, err = newDefaultNode(cfg, logger)
 	assert.Nil(t, ns)
 	assert.Equal(t, errors.New("the psql connection settings cannot be empty"), err)
+	t.Cleanup(cleanup(ns))
 
 	var psqlConn = "test"
 
@@ -591,18 +644,21 @@ func TestNodeSetEventSink(t *testing.T) {
 	var e = errors.New("found duplicated sinks, please check the tx-index section in the config.toml")
 	cfg.TxIndex.Indexer = []string{"psql", "kv", "Kv"}
 	cfg.TxIndex.PsqlConn = psqlConn
-	_, err = newDefaultNode(cfg, logger)
+	ns, err = newDefaultNode(cfg, logger)
 	require.Error(t, err)
 	assert.Equal(t, e, err)
+	t.Cleanup(cleanup(ns))
 
 	cfg.TxIndex.Indexer = []string{"Psql", "kV", "kv", "pSql"}
 	cfg.TxIndex.PsqlConn = psqlConn
-	_, err = newDefaultNode(cfg, logger)
+	ns, err = newDefaultNode(cfg, logger)
 	require.Error(t, err)
 	assert.Equal(t, e, err)
+	t.Cleanup(cleanup(ns))
 }
 
-func state(nVals int, height int64) (sm.State, dbm.DB, []types.PrivValidator) {
+func state(t *testing.T, nVals int, height int64) (sm.State, dbm.DB, []types.PrivValidator) {
+	t.Helper()
 	privVals := make([]types.PrivValidator, nVals)
 	vals := make([]types.GenesisValidator, nVals)
 	for i := 0; i < nVals; i++ {
@@ -623,17 +679,15 @@ func state(nVals int, height int64) (sm.State, dbm.DB, []types.PrivValidator) {
 
 	// save validators to db for 2 heights
 	stateDB := dbm.NewMemDB()
+	t.Cleanup(func() { require.NoError(t, stateDB.Close()) })
+
 	stateStore := sm.NewStore(stateDB)
-	if err := stateStore.Save(s); err != nil {
-		panic(err)
-	}
+	require.NoError(t, stateStore.Save(s))
 
 	for i := 1; i < int(height); i++ {
 		s.LastBlockHeight++
 		s.LastValidators = s.Validators.Copy()
-		if err := stateStore.Save(s); err != nil {
-			panic(err)
-		}
+		require.NoError(t, stateStore.Save(s))
 	}
 	return s, stateDB, privVals
 }
diff --git a/rpc/client/event_test.go b/rpc/client/event_test.go
index 54d19a2012..3b91de107c 100644
--- a/rpc/client/event_test.go
+++ b/rpc/client/event_test.go
@@ -3,7 +3,6 @@ package client_test
 import (
 	"context"
 	"fmt"
-	"reflect"
 	"testing"
 	"time"
 
@@ -17,7 +16,7 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-var waitForEventTimeout = 8 * time.Second
+const waitForEventTimeout = 2 * time.Second
 
 // MakeTxKV returns a text transaction, allong with expected key, value pair
 func MakeTxKV() ([]byte, []byte, []byte) {
@@ -26,164 +25,41 @@ func MakeTxKV() ([]byte, []byte, []byte) {
 	return k, v, append(k, append([]byte("="), v...)...)
 }
 
-func TestHeaderEvents(t *testing.T) {
-	n, conf := NodeSuite(t)
-
-	for i, c := range GetClients(t, n, conf) {
-		i, c := i, c
-		t.Run(reflect.TypeOf(c).String(), func(t *testing.T) {
-			// start for this test it if it wasn't already running
-			if !c.IsRunning() {
-				// if so, then we start it, listen, and stop it.
-				err := c.Start()
-				require.Nil(t, err, "%d: %+v", i, err)
-				t.Cleanup(func() {
-					if err := c.Stop(); err != nil {
-						t.Error(err)
-					}
-				})
-			}
-
-			evt, err := client.WaitForOneEvent(c, types.EventNewBlockHeaderValue, waitForEventTimeout)
-			require.Nil(t, err, "%d: %+v", i, err)
-			_, ok := evt.(types.EventDataNewBlockHeader)
-			require.True(t, ok, "%d: %#v", i, evt)
-			// TODO: more checks...
-		})
-	}
-}
-
-// subscribe to new blocks and make sure height increments by 1
-func TestBlockEvents(t *testing.T) {
-	n, conf := NodeSuite(t)
-	for _, c := range GetClients(t, n, conf) {
-		c := c
-		t.Run(reflect.TypeOf(c).String(), func(t *testing.T) {
-
-			// start for this test it if it wasn't already running
-			if !c.IsRunning() {
-				// if so, then we start it, listen, and stop it.
-				err := c.Start()
-				require.Nil(t, err)
-				t.Cleanup(func() {
-					if err := c.Stop(); err != nil {
-						t.Error(err)
-					}
-				})
-			}
-
-			const subscriber = "TestBlockEvents"
-
-			eventCh, err := c.Subscribe(context.Background(), subscriber, types.QueryForEvent(types.EventNewBlockValue).String())
-			require.NoError(t, err)
-			t.Cleanup(func() {
-				if err := c.UnsubscribeAll(context.Background(), subscriber); err != nil {
-					t.Error(err)
-				}
-			})
-
-			var firstBlockHeight int64
-			for i := int64(0); i < 3; i++ {
-				event := <-eventCh
-				blockEvent, ok := event.Data.(types.EventDataNewBlock)
-				require.True(t, ok)
-
-				block := blockEvent.Block
-
-				if firstBlockHeight == 0 {
-					firstBlockHeight = block.Header.Height
-				}
-
-				require.Equal(t, firstBlockHeight+i, block.Header.Height)
-			}
-		})
-	}
-}
-
-func TestTxEventsSentWithBroadcastTxAsync(t *testing.T) { testTxEventsSent(t, "async") }
-func TestTxEventsSentWithBroadcastTxSync(t *testing.T)  { testTxEventsSent(t, "sync") }
-
-func testTxEventsSent(t *testing.T, broadcastMethod string) {
-	n, conf := NodeSuite(t)
-	for _, c := range GetClients(t, n, conf) {
-		c := c
-		t.Run(reflect.TypeOf(c).String(), func(t *testing.T) {
-
-			// start for this test it if it wasn't already running
-			if !c.IsRunning() {
-				// if so, then we start it, listen, and stop it.
-				err := c.Start()
-				require.Nil(t, err)
-				t.Cleanup(func() {
-					if err := c.Stop(); err != nil {
-						t.Error(err)
-					}
-				})
-			}
-
-			// make the tx
-			_, _, tx := MakeTxKV()
-
-			// send
-			go func() {
-				var (
-					txres *coretypes.ResultBroadcastTx
-					err   error
-					ctx   = context.Background()
-				)
-				switch broadcastMethod {
-				case "async":
-					txres, err = c.BroadcastTxAsync(ctx, tx)
-				case "sync":
-					txres, err = c.BroadcastTxSync(ctx, tx)
-				default:
-					panic(fmt.Sprintf("Unknown broadcastMethod %s", broadcastMethod))
-				}
-				if assert.NoError(t, err) {
-					assert.Equal(t, txres.Code, abci.CodeTypeOK)
-				}
-			}()
-
-			// and wait for confirmation
-			evt, err := client.WaitForOneEvent(c, types.EventTxValue, waitForEventTimeout)
-			require.Nil(t, err)
-
-			// and make sure it has the proper info
-			txe, ok := evt.(types.EventDataTx)
-			require.True(t, ok)
-
-			// make sure this is the proper tx
-			require.EqualValues(t, tx, txe.Tx)
-			require.True(t, txe.Result.IsOK())
-		})
-	}
-}
-
-// Test HTTPClient resubscribes upon disconnect && subscription error.
-// Test Local client resubscribes upon subscription error.
-func TestClientsResubscribe(t *testing.T) {
-	// TODO(melekes)
-}
-
-func TestHTTPReturnsErrorIfClientIsNotRunning(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, conf := NodeSuite(t)
-
-	c := getHTTPClient(t, conf)
-
-	// on Subscribe
-	_, err := c.Subscribe(ctx, "TestHeaderEvents",
-		types.QueryForEvent(types.EventNewBlockHeaderValue).String())
-	assert.Error(t, err)
-
-	// on Unsubscribe
-	err = c.Unsubscribe(ctx, "TestHeaderEvents",
-		types.QueryForEvent(types.EventNewBlockHeaderValue).String())
-	assert.Error(t, err)
-
-	// on UnsubscribeAll
-	err = c.UnsubscribeAll(ctx, "TestHeaderEvents")
-	assert.Error(t, err)
+func testTxEventsSent(ctx context.Context, t *testing.T, broadcastMethod string, c client.Client) {
+	// make the tx
+	_, _, tx := MakeTxKV()
+
+	// send
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		var (
+			txres *coretypes.ResultBroadcastTx
+			err   error
+		)
+		switch broadcastMethod {
+		case "async":
+			txres, err = c.BroadcastTxAsync(ctx, tx)
+		case "sync":
+			txres, err = c.BroadcastTxSync(ctx, tx)
+		default:
+			panic(fmt.Sprintf("Unknown broadcastMethod %s", broadcastMethod))
+		}
+		if assert.NoError(t, err) {
+			assert.Equal(t, txres.Code, abci.CodeTypeOK)
+		}
+	}()
+
+	// and wait for confirmation
+	evt, err := client.WaitForOneEvent(c, types.EventTxValue, waitForEventTimeout)
+	require.Nil(t, err)
+
+	// and make sure it has the proper info
+	txe, ok := evt.(types.EventDataTx)
+	require.True(t, ok)
+
+	// make sure this is the proper tx
+	require.EqualValues(t, tx, txe.Tx)
+	require.True(t, txe.Result.IsOK())
+	<-done
 }
diff --git a/rpc/client/examples_test.go b/rpc/client/examples_test.go
index 1acc29c110..38fb4fcf7b 100644
--- a/rpc/client/examples_test.go
+++ b/rpc/client/examples_test.go
@@ -3,16 +3,20 @@ package client_test
 import (
 	"bytes"
 	"context"
-	"fmt"
 	"log"
+	"net/http"
+	"testing"
+	"time"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	rpchttp "github.com/tendermint/tendermint/rpc/client/http"
 	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctest "github.com/tendermint/tendermint/rpc/test"
 )
 
-func ExampleHTTP_simple() {
+func TestHTTPSimple(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
@@ -29,9 +33,7 @@ func ExampleHTTP_simple() {
 	// Create our RPC client
 	rpcAddr := conf.RPC.ListenAddress
 	c, err := rpchttp.New(rpcAddr)
-	if err != nil {
-		log.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	// Create a transaction
 	k := []byte("name")
@@ -41,6 +43,7 @@ func ExampleHTTP_simple() {
 	// Broadcast the transaction and wait for it to commit (rather use
 	// c.BroadcastTxSync though in production).
 	bres, err := c.BroadcastTxCommit(context.Background(), tx)
+	require.NoError(t, err)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -50,30 +53,19 @@ func ExampleHTTP_simple() {
 
 	// Now try to fetch the value for the key
 	qres, err := c.ABCIQuery(context.Background(), "/key", k)
-	if err != nil {
-		log.Fatal(err)
-	}
-	if qres.Response.IsErr() {
-		log.Fatal("ABCIQuery failed")
-	}
-	if !bytes.Equal(qres.Response.Key, k) {
-		log.Fatal("returned key does not match queried key")
-	}
-	if !bytes.Equal(qres.Response.Value, v) {
-		log.Fatal("returned value does not match sent value")
-	}
-
-	fmt.Println("Sent tx     :", string(tx))
-	fmt.Println("Queried for :", string(qres.Response.Key))
-	fmt.Println("Got value   :", string(qres.Response.Value))
-
-	// Output:
-	// Sent tx     : name=satoshi
-	// Queried for : name
-	// Got value   : satoshi
+	require.NoError(t, err)
+	require.False(t, qres.Response.IsErr(), "ABCIQuery failed")
+	require.True(t, bytes.Equal(qres.Response.Key, k),
+		"returned key does not match queried key")
+	require.True(t, bytes.Equal(qres.Response.Value, v),
+		"returned value does not match sent value [%s]", string(v))
+
+	assert.Equal(t, "name=satoshi", string(tx), "sent tx")
+	assert.Equal(t, "name", string(qres.Response.Key), "queried for")
+	assert.Equal(t, "satoshi", string(qres.Response.Value), "got value")
 }
 
-func ExampleHTTP_batching() {
+func TestHTTPBatching(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
@@ -88,10 +80,8 @@ func ExampleHTTP_batching() {
 	defer func() { _ = closer(ctx) }()
 
 	rpcAddr := conf.RPC.ListenAddress
-	c, err := rpchttp.New(rpcAddr)
-	if err != nil {
-		log.Fatal(err)
-	}
+	c, err := rpchttp.NewWithClient(rpcAddr, http.DefaultClient)
+	require.NoError(t, err)
 
 	// Create our two transactions
 	k1 := []byte("firstName")
@@ -111,41 +101,51 @@ func ExampleHTTP_batching() {
 	for _, tx := range txs {
 		// Broadcast the transaction and wait for it to commit (rather use
 		// c.BroadcastTxSync though in production).
-		if _, err := batch.BroadcastTxCommit(context.Background(), tx); err != nil {
-			log.Fatal(err)
-		}
+		_, err := batch.BroadcastTxSync(ctx, tx)
+		require.NoError(t, err)
 	}
 
 	// Send the batch of 2 transactions
-	if _, err := batch.Send(context.Background()); err != nil {
-		log.Fatal(err)
-	}
-
-	// Now let's query for the original results as a batch
-	keys := [][]byte{k1, k2}
-	for _, key := range keys {
-		if _, err := batch.ABCIQuery(context.Background(), "/key", key); err != nil {
-			log.Fatal(err)
-		}
-	}
+	_, err = batch.Send(ctx)
+	require.NoError(t, err)
+
+	// wait for the transaction to land, we could poll more for
+	// the transactions to land definitively.
+	require.Eventually(t,
+		func() bool {
+			// Now let's query for the original results as a batch
+			exists := 0
+			for _, key := range [][]byte{k1, k2} {
+				_, err := batch.ABCIQuery(context.Background(), "/key", key)
+				if err == nil {
+					exists++
+
+				}
+			}
+			return exists == 2
+		},
+		10*time.Second,
+		time.Second,
+	)
 
 	// Send the 2 queries and keep the results
-	results, err := batch.Send(context.Background())
-	if err != nil {
-		log.Fatal(err)
-	}
+	results, err := batch.Send(ctx)
+	require.NoError(t, err)
 
+	require.Len(t, results, 2)
 	// Each result in the returned list is the deserialized result of each
 	// respective ABCIQuery response
 	for _, result := range results {
 		qr, ok := result.(*coretypes.ResultABCIQuery)
-		if !ok {
-			log.Fatal("invalid result type from ABCIQuery request")
+		require.True(t, ok, "invalid result type from ABCIQuery request")
+
+		switch string(qr.Response.Key) {
+		case "firstName":
+			require.Equal(t, "satoshi", string(qr.Response.Value))
+		case "lastName":
+			require.Equal(t, "nakamoto", string(qr.Response.Value))
+		default:
+			t.Fatalf("encountered unknown key %q", string(qr.Response.Key))
 		}
-		fmt.Println(string(qr.Response.Key), "=", string(qr.Response.Value))
 	}
-
-	// Output:
-	// firstName = satoshi
-	// lastName = nakamoto
 }
diff --git a/rpc/client/http/http.go b/rpc/client/http/http.go
index d0c1d56218..5bd7b398a9 100644
--- a/rpc/client/http/http.go
+++ b/rpc/client/http/http.go
@@ -2,6 +2,7 @@ package http
 
 import (
 	"context"
+	"errors"
 	"net/http"
 	"time"
 
@@ -120,20 +121,20 @@ func NewWithTimeout(remote string, t time.Duration) (*HTTP, error) {
 }
 
 // NewWithClient allows you to set a custom http client. An error is returned
-// on invalid remote. The function panics when client is nil.
+// on invalid remote. The function returns an error when client is nil
+// or an invalid remote.
 func NewWithClient(remote string, c *http.Client) (*HTTP, error) {
 	if c == nil {
-		panic("nil http.Client")
+		return nil, errors.New("nil client")
 	}
 	return NewWithClientAndWSOptions(remote, c, DefaultWSOptions())
 }
 
 // NewWithClientAndWSOptions allows you to set a custom http client and
-// WebSocket options. An error is returned on invalid remote. The function
-// panics when client is nil.
+// WebSocket options. An error is returned on invalid remote or nil client.
 func NewWithClientAndWSOptions(remote string, c *http.Client, wso WSOptions) (*HTTP, error) {
 	if c == nil {
-		panic("nil http.Client")
+		return nil, errors.New("nil client")
 	}
 	rpc, err := jsonrpcclient.NewWithHTTPClient(remote, c)
 	if err != nil {
diff --git a/rpc/client/main_test.go b/rpc/client/main_test.go
index 4e2c0405c6..c2e0dc3cda 100644
--- a/rpc/client/main_test.go
+++ b/rpc/client/main_test.go
@@ -7,6 +7,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/config"
@@ -30,9 +31,11 @@ func NodeSuite(t *testing.T) (service.Service, *config.Config) {
 	node, closer, err := rpctest.StartTendermint(ctx, conf, app, rpctest.SuppressStdout)
 	require.NoError(t, err)
 	t.Cleanup(func() {
-		_ = closer(ctx)
 		cancel()
-		app.Close()
+		assert.NoError(t, node.Stop())
+		assert.NoError(t, closer(ctx))
+		assert.NoError(t, app.Close())
+		node.Wait()
 		_ = os.RemoveAll(dir)
 	})
 	return node, conf
diff --git a/rpc/client/rpc_test.go b/rpc/client/rpc_test.go
index 8a68458313..d7554d1749 100644
--- a/rpc/client/rpc_test.go
+++ b/rpc/client/rpc_test.go
@@ -33,10 +33,16 @@ func getHTTPClient(t *testing.T, conf *config.Config) *rpchttp.HTTP {
 	t.Helper()
 
 	rpcAddr := conf.RPC.ListenAddress
-	c, err := rpchttp.New(rpcAddr)
+	c, err := rpchttp.NewWithClient(rpcAddr, http.DefaultClient)
 	require.NoError(t, err)
 
 	c.SetLogger(log.TestingLogger())
+	t.Cleanup(func() {
+		if c.IsRunning() {
+			require.NoError(t, c.Stop())
+		}
+	})
+
 	return c
 }
 
@@ -44,10 +50,18 @@ func getHTTPClientWithTimeout(t *testing.T, conf *config.Config, timeout time.Du
 	t.Helper()
 
 	rpcAddr := conf.RPC.ListenAddress
-	c, err := rpchttp.NewWithTimeout(rpcAddr, timeout)
+
+	http.DefaultClient.Timeout = timeout
+	c, err := rpchttp.NewWithClient(rpcAddr, http.DefaultClient)
 	require.NoError(t, err)
 
 	c.SetLogger(log.TestingLogger())
+	t.Cleanup(func() {
+		http.DefaultClient.Timeout = 0
+		if c.IsRunning() {
+			require.NoError(t, c.Stop())
+		}
+	})
 
 	return c
 }
@@ -63,382 +77,433 @@ func GetClients(t *testing.T, ns service.Service, conf *config.Config) []client.
 	require.NoError(t, err)
 
 	return []client.Client{
-		getHTTPClient(t, conf),
 		ncl,
+		getHTTPClient(t, conf),
 	}
 }
 
-func TestNilCustomHTTPClient(t *testing.T) {
-	require.Panics(t, func() {
-		_, _ = rpchttp.NewWithClient("http://example.com", nil)
-	})
-	require.Panics(t, func() {
-		_, _ = rpcclient.NewWithHTTPClient("http://example.com", nil)
-	})
-}
-
-func TestParseInvalidAddress(t *testing.T) {
-	_, conf := NodeSuite(t)
-	// should remove trailing /
-	invalidRemote := conf.RPC.ListenAddress + "/"
-	_, err := rpchttp.New(invalidRemote)
-	require.NoError(t, err)
-}
-
-func TestCustomHTTPClient(t *testing.T) {
-	_, conf := NodeSuite(t)
-	remote := conf.RPC.ListenAddress
-	c, err := rpchttp.NewWithClient(remote, http.DefaultClient)
-	require.Nil(t, err)
-	status, err := c.Status(context.Background())
-	require.NoError(t, err)
-	require.NotNil(t, status)
-}
-
-func TestCorsEnabled(t *testing.T) {
-	_, conf := NodeSuite(t)
-	origin := conf.RPC.CORSAllowedOrigins[0]
-	remote := strings.ReplaceAll(conf.RPC.ListenAddress, "tcp", "http")
-
-	req, err := http.NewRequest("GET", remote, nil)
-	require.Nil(t, err, "%+v", err)
-	req.Header.Set("Origin", origin)
-	c := &http.Client{}
-	resp, err := c.Do(req)
-	require.Nil(t, err, "%+v", err)
-	defer resp.Body.Close()
-
-	assert.Equal(t, resp.Header.Get("Access-Control-Allow-Origin"), origin)
-}
-
-// Make sure status is correct (we connect properly)
-func TestStatus(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, conf := NodeSuite(t)
-	for i, c := range GetClients(t, n, conf) {
-		moniker := conf.Moniker
-		status, err := c.Status(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.Equal(t, moniker, status.NodeInfo.Moniker)
-	}
-}
-
-// Make sure info is correct (we connect properly)
-func TestInfo(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	n, conf := NodeSuite(t)
-
-	for i, c := range GetClients(t, n, conf) {
-		// status, err := c.Status()
-		// require.Nil(t, err, "%+v", err)
-		info, err := c.ABCIInfo(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		// TODO: this is not correct - fix merkleeyes!
-		// assert.EqualValues(t, status.SyncInfo.LatestBlockHeight, info.Response.LastBlockHeight)
-		assert.True(t, strings.Contains(info.Response.Data, "size"))
-	}
-}
-
-func TestNetInfo(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, conf := NodeSuite(t)
-	for i, c := range GetClients(t, n, conf) {
-		nc, ok := c.(client.NetworkClient)
-		require.True(t, ok, "%d", i)
-		netinfo, err := nc.NetInfo(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.True(t, netinfo.Listening)
-		assert.Equal(t, 0, len(netinfo.Peers))
-	}
-}
-
-func TestDumpConsensusState(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, conf := NodeSuite(t)
-	for i, c := range GetClients(t, n, conf) {
-		// FIXME: fix server so it doesn't panic on invalid input
-		nc, ok := c.(client.NetworkClient)
-		require.True(t, ok, "%d", i)
-		cons, err := nc.DumpConsensusState(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.NotEmpty(t, cons.RoundState)
-		assert.Empty(t, cons.Peers)
-	}
-}
-
-func TestConsensusState(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, conf := NodeSuite(t)
-
-	for i, c := range GetClients(t, n, conf) {
-		// FIXME: fix server so it doesn't panic on invalid input
-		nc, ok := c.(client.NetworkClient)
-		require.True(t, ok, "%d", i)
-		cons, err := nc.ConsensusState(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.NotEmpty(t, cons.RoundState)
-	}
-}
-
-func TestHealth(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, conf := NodeSuite(t)
-
-	for i, c := range GetClients(t, n, conf) {
-		nc, ok := c.(client.NetworkClient)
-		require.True(t, ok, "%d", i)
-		_, err := nc.Health(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-	}
-}
-
-func TestGenesisAndValidators(t *testing.T) {
+func TestClientOperations(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	n, conf := NodeSuite(t)
-	for i, c := range GetClients(t, n, conf) {
-
-		// make sure this is the right genesis file
-		gen, err := c.Genesis(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		// get the genesis validator
-		require.Equal(t, 1, len(gen.Genesis.Validators))
-		gval := gen.Genesis.Validators[0]
-
-		// get the current validators
-		h := int64(1)
-		vals, err := c.Validators(ctx, &h, nil, nil)
-		require.Nil(t, err, "%d: %+v", i, err)
-		require.Equal(t, 1, len(vals.Validators))
-		require.Equal(t, 1, vals.Count)
-		require.Equal(t, 1, vals.Total)
-		val := vals.Validators[0]
-
-		// make sure the current set is also the genesis set
-		assert.Equal(t, gval.Power, val.VotingPower)
-		assert.Equal(t, gval.PubKey, val.PubKey)
-	}
-}
-
-func TestGenesisChunked(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	_, conf := NodeSuite(t)
 
-	n, conf := NodeSuite(t)
+	t.Run("NilCustomHTTPClient", func(t *testing.T) {
+		_, err := rpchttp.NewWithClient("http://example.com", nil)
+		require.Error(t, err)
 
-	for _, c := range GetClients(t, n, conf) {
-		first, err := c.GenesisChunked(ctx, 0)
+		_, err = rpcclient.NewWithHTTPClient("http://example.com", nil)
+		require.Error(t, err)
+	})
+	t.Run("ParseInvalidAddress", func(t *testing.T) {
+		// should remove trailing /
+		invalidRemote := conf.RPC.ListenAddress + "/"
+		_, err := rpchttp.New(invalidRemote)
 		require.NoError(t, err)
-
-		decoded := make([]string, 0, first.TotalChunks)
-		for i := 0; i < first.TotalChunks; i++ {
-			chunk, err := c.GenesisChunked(ctx, uint(i))
+	})
+	t.Run("CustomHTTPClient", func(t *testing.T) {
+		remote := conf.RPC.ListenAddress
+		c, err := rpchttp.NewWithClient(remote, http.DefaultClient)
+		require.Nil(t, err)
+		status, err := c.Status(ctx)
+		require.NoError(t, err)
+		require.NotNil(t, status)
+	})
+	t.Run("CorsEnabled", func(t *testing.T) {
+		origin := conf.RPC.CORSAllowedOrigins[0]
+		remote := strings.ReplaceAll(conf.RPC.ListenAddress, "tcp", "http")
+
+		req, err := http.NewRequestWithContext(ctx, "GET", remote, nil)
+		require.Nil(t, err, "%+v", err)
+		req.Header.Set("Origin", origin)
+		resp, err := http.DefaultClient.Do(req)
+		require.Nil(t, err, "%+v", err)
+		defer resp.Body.Close()
+
+		assert.Equal(t, resp.Header.Get("Access-Control-Allow-Origin"), origin)
+	})
+	t.Run("Batching", func(t *testing.T) {
+		t.Run("JSONRPCCalls", func(t *testing.T) {
+			c := getHTTPClient(t, conf)
+			testBatchedJSONRPCCalls(ctx, t, c)
+		})
+		t.Run("JSONRPCCallsCancellation", func(t *testing.T) {
+			_, _, tx1 := MakeTxKV()
+			_, _, tx2 := MakeTxKV()
+
+			c := getHTTPClient(t, conf)
+			batch := c.NewBatch()
+			_, err := batch.BroadcastTxCommit(ctx, tx1)
 			require.NoError(t, err)
-			data, err := base64.StdEncoding.DecodeString(chunk.Data)
+			_, err = batch.BroadcastTxCommit(ctx, tx2)
 			require.NoError(t, err)
-			decoded = append(decoded, string(data))
-
-		}
-		doc := []byte(strings.Join(decoded, ""))
-
-		var out types.GenesisDoc
-		require.NoError(t, tmjson.Unmarshal(doc, &out),
-			"first: %+v, doc: %s", first, string(doc))
-	}
-}
-
-func TestABCIQuery(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, conf := NodeSuite(t)
-
-	for i, c := range GetClients(t, n, conf) {
-		// write something
-		k, v, tx := MakeTxKV()
-		bres, err := c.BroadcastTxCommit(ctx, tx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		apph := bres.Height + 1 // this is where the tx will be applied to the state
-
-		// wait before querying
-		err = client.WaitForHeight(c, apph, nil)
-		require.NoError(t, err)
-		res, err := c.ABCIQuery(ctx, "/key", k)
-		qres := res.Response
-		if assert.Nil(t, err) && assert.True(t, qres.IsOK()) {
-			assert.EqualValues(t, v, qres.Value)
-		}
-	}
+			// we should have 2 requests waiting
+			require.Equal(t, 2, batch.Count())
+			// we want to make sure we cleared 2 pending requests
+			require.Equal(t, 2, batch.Clear())
+			// now there should be no batched requests
+			require.Equal(t, 0, batch.Count())
+		})
+		t.Run("SendingEmptyRequest", func(t *testing.T) {
+			c := getHTTPClient(t, conf)
+			batch := c.NewBatch()
+			_, err := batch.Send(ctx)
+			require.Error(t, err, "sending an empty batch of JSON RPC requests should result in an error")
+		})
+		t.Run("ClearingEmptyRequest", func(t *testing.T) {
+			c := getHTTPClient(t, conf)
+			batch := c.NewBatch()
+			require.Zero(t, batch.Clear(), "clearing an empty batch of JSON RPC requests should result in a 0 result")
+		})
+		t.Run("ConcurrentJSONRPC", func(t *testing.T) {
+			var wg sync.WaitGroup
+			c := getHTTPClient(t, conf)
+			for i := 0; i < 50; i++ {
+				wg.Add(1)
+				go func() {
+					defer wg.Done()
+					testBatchedJSONRPCCalls(ctx, t, c)
+				}()
+			}
+			wg.Wait()
+		})
+	})
+	t.Run("HTTPReturnsErrorIfClientIsNotRunning", func(t *testing.T) {
+		c := getHTTPClientWithTimeout(t, conf, 100*time.Millisecond)
+
+		// on Subscribe
+		_, err := c.Subscribe(ctx, "TestHeaderEvents",
+			types.QueryForEvent(types.EventNewBlockHeaderValue).String())
+		assert.Error(t, err)
+
+		// on Unsubscribe
+		err = c.Unsubscribe(ctx, "TestHeaderEvents",
+			types.QueryForEvent(types.EventNewBlockHeaderValue).String())
+		assert.Error(t, err)
+
+		// on UnsubscribeAll
+		err = c.UnsubscribeAll(ctx, "TestHeaderEvents")
+		assert.Error(t, err)
+	})
 }
 
-// Make some app checks
-func TestAppCalls(t *testing.T) {
+// Make sure info is correct (we connect properly)
+func TestClientMethodCalls(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-
 	n, conf := NodeSuite(t)
 
-	for i, c := range GetClients(t, n, conf) {
-
-		// get an offset of height to avoid racing and guessing
-		s, err := c.Status(ctx)
-		require.NoError(t, err)
-		// sh is start height or status height
-		sh := s.SyncInfo.LatestBlockHeight
-
-		// look for the future
-		h := sh + 20
-		_, err = c.Block(ctx, &h)
-		require.Error(t, err) // no block yet
-
-		// write something
-		k, v, tx := MakeTxKV()
-		bres, err := c.BroadcastTxCommit(ctx, tx)
-		require.NoError(t, err)
-		require.True(t, bres.DeliverTx.IsOK())
-		txh := bres.Height
-		apph := txh + 1 // this is where the tx will be applied to the state
-
-		// wait before querying
-		err = client.WaitForHeight(c, apph, nil)
-		require.NoError(t, err)
-
-		_qres, err := c.ABCIQueryWithOptions(ctx, "/key", k, client.ABCIQueryOptions{Prove: false})
-		require.NoError(t, err)
-		qres := _qres.Response
-		if assert.True(t, qres.IsOK()) {
-			assert.Equal(t, k, qres.Key)
-			assert.EqualValues(t, v, qres.Value)
-		}
-
-		// make sure we can lookup the tx with proof
-		ptx, err := c.Tx(ctx, bres.Hash, true)
-		require.NoError(t, err)
-		assert.EqualValues(t, txh, ptx.Height)
-		assert.EqualValues(t, tx, ptx.Tx)
-
-		// and we can even check the block is added
-		block, err := c.Block(ctx, &apph)
-		require.NoError(t, err)
-		appHash := block.Block.Header.AppHash
-		assert.True(t, len(appHash) > 0)
-		assert.EqualValues(t, apph, block.Block.Header.Height)
-
-		blockByHash, err := c.BlockByHash(ctx, block.BlockID.Hash)
-		require.NoError(t, err)
-		require.Equal(t, block, blockByHash)
-
-		// now check the results
-		blockResults, err := c.BlockResults(ctx, &txh)
-		require.NoError(t, err, "%d: %+v", i, err)
-		assert.Equal(t, txh, blockResults.Height)
-		if assert.Equal(t, 1, len(blockResults.TxsResults)) {
-			// check success code
-			assert.EqualValues(t, 0, blockResults.TxsResults[0].Code)
-		}
-
-		// check blockchain info, now that we know there is info
-		info, err := c.BlockchainInfo(ctx, apph, apph)
-		require.NoError(t, err)
-		assert.True(t, info.LastHeight >= apph)
-		if assert.Equal(t, 1, len(info.BlockMetas)) {
-			lastMeta := info.BlockMetas[0]
-			assert.EqualValues(t, apph, lastMeta.Header.Height)
-			blockData := block.Block
-			assert.Equal(t, blockData.Header.AppHash, lastMeta.Header.AppHash)
-			assert.Equal(t, block.BlockID, lastMeta.BlockID)
-		}
-
-		// and get the corresponding commit with the same apphash
-		commit, err := c.Commit(ctx, &apph)
-		require.NoError(t, err)
-		cappHash := commit.Header.AppHash
-		assert.Equal(t, appHash, cappHash)
-		assert.NotNil(t, commit.Commit)
-
-		// compare the commits (note Commit(2) has commit from Block(3))
-		h = apph - 1
-		commit2, err := c.Commit(ctx, &h)
-		require.NoError(t, err)
-		assert.Equal(t, block.Block.LastCommitHash, commit2.Commit.Hash())
-
-		// and we got a proof that works!
-		_pres, err := c.ABCIQueryWithOptions(ctx, "/key", k, client.ABCIQueryOptions{Prove: true})
-		require.NoError(t, err)
-		pres := _pres.Response
-		assert.True(t, pres.IsOK())
-
-		// XXX Test proof
-	}
-}
-
-func TestBlockchainInfo(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, conf := NodeSuite(t)
+	pool := getMempool(t, n)
 
 	for i, c := range GetClients(t, n, conf) {
-		err := client.WaitForHeight(c, 10, nil)
-		require.NoError(t, err)
+		t.Run(fmt.Sprintf("%T", c), func(t *testing.T) {
+			t.Run("Status", func(t *testing.T) {
+				status, err := c.Status(ctx)
+				require.Nil(t, err, "%d: %+v", i, err)
+				assert.Equal(t, conf.Moniker, status.NodeInfo.Moniker)
+			})
+			t.Run("Info", func(t *testing.T) {
+				info, err := c.ABCIInfo(ctx)
+				require.NoError(t, err)
+
+				status, err := c.Status(ctx)
+				require.NoError(t, err)
+
+				assert.GreaterOrEqual(t, status.SyncInfo.LatestBlockHeight, info.Response.LastBlockHeight)
+				assert.True(t, strings.Contains(info.Response.Data, "size"))
+			})
+			t.Run("NetInfo", func(t *testing.T) {
+				nc, ok := c.(client.NetworkClient)
+				require.True(t, ok, "%d", i)
+				netinfo, err := nc.NetInfo(ctx)
+				require.Nil(t, err, "%d: %+v", i, err)
+				assert.True(t, netinfo.Listening)
+				assert.Equal(t, 0, len(netinfo.Peers))
+			})
+			t.Run("DumpConsensusState", func(t *testing.T) {
+				// FIXME: fix server so it doesn't panic on invalid input
+				nc, ok := c.(client.NetworkClient)
+				require.True(t, ok, "%d", i)
+				cons, err := nc.DumpConsensusState(ctx)
+				require.Nil(t, err, "%d: %+v", i, err)
+				assert.NotEmpty(t, cons.RoundState)
+				assert.Empty(t, cons.Peers)
+			})
+			t.Run("ConsensusState", func(t *testing.T) {
+				// FIXME: fix server so it doesn't panic on invalid input
+				nc, ok := c.(client.NetworkClient)
+				require.True(t, ok, "%d", i)
+				cons, err := nc.ConsensusState(ctx)
+				require.Nil(t, err, "%d: %+v", i, err)
+				assert.NotEmpty(t, cons.RoundState)
+			})
+			t.Run("Health", func(t *testing.T) {
+				nc, ok := c.(client.NetworkClient)
+				require.True(t, ok, "%d", i)
+				_, err := nc.Health(ctx)
+				require.Nil(t, err, "%d: %+v", i, err)
+			})
+			t.Run("GenesisAndValidators", func(t *testing.T) {
+				// make sure this is the right genesis file
+				gen, err := c.Genesis(ctx)
+				require.Nil(t, err, "%d: %+v", i, err)
+				// get the genesis validator
+				require.Equal(t, 1, len(gen.Genesis.Validators))
+				gval := gen.Genesis.Validators[0]
+
+				// get the current validators
+				h := int64(1)
+				vals, err := c.Validators(ctx, &h, nil, nil)
+				require.Nil(t, err, "%d: %+v", i, err)
+				require.Equal(t, 1, len(vals.Validators))
+				require.Equal(t, 1, vals.Count)
+				require.Equal(t, 1, vals.Total)
+				val := vals.Validators[0]
+
+				// make sure the current set is also the genesis set
+				assert.Equal(t, gval.Power, val.VotingPower)
+				assert.Equal(t, gval.PubKey, val.PubKey)
+			})
+			t.Run("GenesisChunked", func(t *testing.T) {
+				first, err := c.GenesisChunked(ctx, 0)
+				require.NoError(t, err)
+
+				decoded := make([]string, 0, first.TotalChunks)
+				for i := 0; i < first.TotalChunks; i++ {
+					chunk, err := c.GenesisChunked(ctx, uint(i))
+					require.NoError(t, err)
+					data, err := base64.StdEncoding.DecodeString(chunk.Data)
+					require.NoError(t, err)
+					decoded = append(decoded, string(data))
 
-		res, err := c.BlockchainInfo(ctx, 0, 0)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.True(t, res.LastHeight > 0)
-		assert.True(t, len(res.BlockMetas) > 0)
-
-		res, err = c.BlockchainInfo(ctx, 1, 1)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.True(t, res.LastHeight > 0)
-		assert.True(t, len(res.BlockMetas) == 1)
-
-		res, err = c.BlockchainInfo(ctx, 1, 10000)
-		require.Nil(t, err, "%d: %+v", i, err)
-		assert.True(t, res.LastHeight > 0)
-		assert.True(t, len(res.BlockMetas) < 100)
-		for _, m := range res.BlockMetas {
-			assert.NotNil(t, m)
-		}
+				}
+				doc := []byte(strings.Join(decoded, ""))
+
+				var out types.GenesisDoc
+				require.NoError(t, tmjson.Unmarshal(doc, &out),
+					"first: %+v, doc: %s", first, string(doc))
+			})
+			t.Run("ABCIQuery", func(t *testing.T) {
+				// write something
+				k, v, tx := MakeTxKV()
+				status, err := c.Status(ctx)
+				require.NoError(t, err)
+				_, err = c.BroadcastTxSync(ctx, tx)
+				require.NoError(t, err, "%d: %+v", i, err)
+				apph := status.SyncInfo.LatestBlockHeight + 2 // this is where the tx will be applied to the state
+
+				// wait before querying
+				err = client.WaitForHeight(c, apph, nil)
+				require.NoError(t, err)
+				res, err := c.ABCIQuery(ctx, "/key", k)
+				qres := res.Response
+				if assert.NoError(t, err) && assert.True(t, qres.IsOK()) {
+					assert.EqualValues(t, v, qres.Value)
+				}
+			})
+			t.Run("AppCalls", func(t *testing.T) {
+				// get an offset of height to avoid racing and guessing
+				s, err := c.Status(ctx)
+				require.NoError(t, err)
+				// sh is start height or status height
+				sh := s.SyncInfo.LatestBlockHeight
+
+				// look for the future
+				h := sh + 20
+				_, err = c.Block(ctx, &h)
+				require.Error(t, err) // no block yet
+
+				// write something
+				k, v, tx := MakeTxKV()
+				bres, err := c.BroadcastTxCommit(ctx, tx)
+				require.NoError(t, err)
+				require.True(t, bres.DeliverTx.IsOK())
+				txh := bres.Height
+				apph := txh + 1 // this is where the tx will be applied to the state
+
+				// wait before querying
+				err = client.WaitForHeight(c, apph, nil)
+				require.NoError(t, err)
+
+				_qres, err := c.ABCIQueryWithOptions(ctx, "/key", k, client.ABCIQueryOptions{Prove: false})
+				require.NoError(t, err)
+				qres := _qres.Response
+				if assert.True(t, qres.IsOK()) {
+					assert.Equal(t, k, qres.Key)
+					assert.EqualValues(t, v, qres.Value)
+				}
 
-		res, err = c.BlockchainInfo(ctx, 10000, 1)
-		require.NotNil(t, err)
-		assert.Nil(t, res)
-		assert.Contains(t, err.Error(), "can't be greater than max")
-	}
-}
+				// make sure we can lookup the tx with proof
+				ptx, err := c.Tx(ctx, bres.Hash, true)
+				require.NoError(t, err)
+				assert.EqualValues(t, txh, ptx.Height)
+				assert.EqualValues(t, tx, ptx.Tx)
 
-func TestBroadcastTxSync(t *testing.T) {
-	n, conf := NodeSuite(t)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+				// and we can even check the block is added
+				block, err := c.Block(ctx, &apph)
+				require.NoError(t, err)
+				appHash := block.Block.Header.AppHash
+				assert.True(t, len(appHash) > 0)
+				assert.EqualValues(t, apph, block.Block.Header.Height)
+
+				blockByHash, err := c.BlockByHash(ctx, block.BlockID.Hash)
+				require.NoError(t, err)
+				require.Equal(t, block, blockByHash)
+
+				// now check the results
+				blockResults, err := c.BlockResults(ctx, &txh)
+				require.NoError(t, err, "%d: %+v", i, err)
+				assert.Equal(t, txh, blockResults.Height)
+				if assert.Equal(t, 1, len(blockResults.TxsResults)) {
+					// check success code
+					assert.EqualValues(t, 0, blockResults.TxsResults[0].Code)
+				}
 
-	// TODO (melekes): use mempool which is set on RPC rather than getting it from node
-	pool := getMempool(t, n)
-	initMempoolSize := pool.Size()
+				// check blockchain info, now that we know there is info
+				info, err := c.BlockchainInfo(ctx, apph, apph)
+				require.NoError(t, err)
+				assert.True(t, info.LastHeight >= apph)
+				if assert.Equal(t, 1, len(info.BlockMetas)) {
+					lastMeta := info.BlockMetas[0]
+					assert.EqualValues(t, apph, lastMeta.Header.Height)
+					blockData := block.Block
+					assert.Equal(t, blockData.Header.AppHash, lastMeta.Header.AppHash)
+					assert.Equal(t, block.BlockID, lastMeta.BlockID)
+				}
 
-	for i, c := range GetClients(t, n, conf) {
-		_, _, tx := MakeTxKV()
-		bres, err := c.BroadcastTxSync(ctx, tx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		require.Equal(t, bres.Code, abci.CodeTypeOK) // FIXME
+				// and get the corresponding commit with the same apphash
+				commit, err := c.Commit(ctx, &apph)
+				require.NoError(t, err)
+				cappHash := commit.Header.AppHash
+				assert.Equal(t, appHash, cappHash)
+				assert.NotNil(t, commit.Commit)
+
+				// compare the commits (note Commit(2) has commit from Block(3))
+				h = apph - 1
+				commit2, err := c.Commit(ctx, &h)
+				require.NoError(t, err)
+				assert.Equal(t, block.Block.LastCommitHash, commit2.Commit.Hash())
+
+				// and we got a proof that works!
+				_pres, err := c.ABCIQueryWithOptions(ctx, "/key", k, client.ABCIQueryOptions{Prove: true})
+				require.NoError(t, err)
+				pres := _pres.Response
+				assert.True(t, pres.IsOK())
+
+				// XXX Test proof
+			})
+			t.Run("BlockchainInfo", func(t *testing.T) {
+				err := client.WaitForHeight(c, 10, nil)
+				require.NoError(t, err)
+
+				res, err := c.BlockchainInfo(ctx, 0, 0)
+				require.Nil(t, err, "%d: %+v", i, err)
+				assert.True(t, res.LastHeight > 0)
+				assert.True(t, len(res.BlockMetas) > 0)
+
+				res, err = c.BlockchainInfo(ctx, 1, 1)
+				require.Nil(t, err, "%d: %+v", i, err)
+				assert.True(t, res.LastHeight > 0)
+				assert.True(t, len(res.BlockMetas) == 1)
+
+				res, err = c.BlockchainInfo(ctx, 1, 10000)
+				require.Nil(t, err, "%d: %+v", i, err)
+				assert.True(t, res.LastHeight > 0)
+				assert.True(t, len(res.BlockMetas) < 100)
+				for _, m := range res.BlockMetas {
+					assert.NotNil(t, m)
+				}
 
-		require.Equal(t, initMempoolSize+1, pool.Size())
+				res, err = c.BlockchainInfo(ctx, 10000, 1)
+				require.NotNil(t, err)
+				assert.Nil(t, res)
+				assert.Contains(t, err.Error(), "can't be greater than max")
+			})
+			t.Run("BroadcastTxCommit", func(t *testing.T) {
+				_, _, tx := MakeTxKV()
+				bres, err := c.BroadcastTxCommit(ctx, tx)
+				require.Nil(t, err, "%d: %+v", i, err)
+				require.True(t, bres.CheckTx.IsOK())
+				require.True(t, bres.DeliverTx.IsOK())
+
+				require.Equal(t, 0, pool.Size())
+			})
+			t.Run("BroadcastTxSync", func(t *testing.T) {
+				_, _, tx := MakeTxKV()
+				initMempoolSize := pool.Size()
+				bres, err := c.BroadcastTxSync(ctx, tx)
+				require.Nil(t, err, "%d: %+v", i, err)
+				require.Equal(t, bres.Code, abci.CodeTypeOK) // FIXME
+
+				require.Equal(t, initMempoolSize+1, pool.Size())
+
+				txs := pool.ReapMaxTxs(len(tx))
+				require.EqualValues(t, tx, txs[0])
+				pool.Flush()
+			})
+			t.Run("CheckTx", func(t *testing.T) {
+				_, _, tx := MakeTxKV()
+
+				res, err := c.CheckTx(ctx, tx)
+				require.NoError(t, err)
+				assert.Equal(t, abci.CodeTypeOK, res.Code)
+
+				assert.Equal(t, 0, pool.Size(), "mempool must be empty")
+			})
+			t.Run("Events", func(t *testing.T) {
+				// start for this test it if it wasn't already running
+				if !c.IsRunning() {
+					// if so, then we start it, listen, and stop it.
+					err := c.Start()
+					require.Nil(t, err)
+					t.Cleanup(func() {
+						if err := c.Stop(); err != nil {
+							t.Error(err)
+						}
+					})
+				}
 
-		txs := pool.ReapMaxTxs(len(tx))
-		require.EqualValues(t, tx, txs[0])
-		pool.Flush()
+				t.Run("Header", func(t *testing.T) {
+					evt, err := client.WaitForOneEvent(c, types.EventNewBlockHeaderValue, waitForEventTimeout)
+					require.Nil(t, err, "%d: %+v", i, err)
+					_, ok := evt.(types.EventDataNewBlockHeader)
+					require.True(t, ok, "%d: %#v", i, evt)
+					// TODO: more checks...
+				})
+				t.Run("Block", func(t *testing.T) {
+					const subscriber = "TestBlockEvents"
+
+					eventCh, err := c.Subscribe(ctx, subscriber, types.QueryForEvent(types.EventNewBlockValue).String())
+					require.NoError(t, err)
+					t.Cleanup(func() {
+						if err := c.UnsubscribeAll(ctx, subscriber); err != nil {
+							t.Error(err)
+						}
+					})
+
+					var firstBlockHeight int64
+					for i := int64(0); i < 3; i++ {
+						event := <-eventCh
+						blockEvent, ok := event.Data.(types.EventDataNewBlock)
+						require.True(t, ok)
+
+						block := blockEvent.Block
+
+						if firstBlockHeight == 0 {
+							firstBlockHeight = block.Header.Height
+						}
+
+						require.Equal(t, firstBlockHeight+i, block.Header.Height)
+					}
+				})
+				t.Run("BroadcastTxAsync", func(t *testing.T) {
+					testTxEventsSent(ctx, t, "async", c)
+				})
+				t.Run("BroadcastTxSync", func(t *testing.T) {
+					testTxEventsSent(ctx, t, "sync", c)
+				})
+			})
+		})
 	}
 }
 
@@ -451,319 +516,268 @@ func getMempool(t *testing.T, srv service.Service) mempool.Mempool {
 	return n.Mempool()
 }
 
-func TestBroadcastTxCommit(t *testing.T) {
+// these cases are roughly the same as the TestClientMethodCalls, but
+// they have to loop over their clients in the individual test cases,
+// so making a separate suite makes more sense, though isn't strictly
+// speaking desirable.
+func TestClientMethodCallsAdvanced(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
 	n, conf := NodeSuite(t)
-
 	pool := getMempool(t, n)
-	for i, c := range GetClients(t, n, conf) {
-		_, _, tx := MakeTxKV()
-		bres, err := c.BroadcastTxCommit(ctx, tx)
-		require.Nil(t, err, "%d: %+v", i, err)
-		require.True(t, bres.CheckTx.IsOK())
-		require.True(t, bres.DeliverTx.IsOK())
-
-		require.Equal(t, 0, pool.Size())
-	}
-}
 
-func TestUnconfirmedTxs(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, _, tx := MakeTxKV()
-	ch := make(chan *abci.Response, 1)
-
-	n, conf := NodeSuite(t)
-	pool := getMempool(t, n)
-	err := pool.CheckTx(ctx, tx, func(resp *abci.Response) { ch <- resp }, mempool.TxInfo{})
-
-	require.NoError(t, err)
-
-	// wait for tx to arrive in mempoool.
-	select {
-	case <-ch:
-	case <-time.After(5 * time.Second):
-		t.Error("Timed out waiting for CheckTx callback")
-	}
+	t.Run("UnconfirmedTxs", func(t *testing.T) {
+		_, _, tx := MakeTxKV()
+		ch := make(chan struct{})
 
-	for _, c := range GetClients(t, n, conf) {
-		mc := c.(client.MempoolClient)
-		limit := 1
-		res, err := mc.UnconfirmedTxs(ctx, &limit)
+		err := pool.CheckTx(ctx, tx, func(_ *abci.Response) { close(ch) }, mempool.TxInfo{})
 		require.NoError(t, err)
 
-		assert.Equal(t, 1, res.Count)
-		assert.Equal(t, 1, res.Total)
-		assert.Equal(t, pool.SizeBytes(), res.TotalBytes)
-		assert.Exactly(t, types.Txs{tx}, types.Txs(res.Txs))
-	}
-
-	pool.Flush()
-}
-
-func TestNumUnconfirmedTxs(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, _, tx := MakeTxKV()
-
-	n, conf := NodeSuite(t)
-	ch := make(chan *abci.Response, 1)
-	pool := getMempool(t, n)
-
-	err := pool.CheckTx(ctx, tx, func(resp *abci.Response) { ch <- resp }, mempool.TxInfo{})
-	require.NoError(t, err)
-
-	// wait for tx to arrive in mempoool.
-	select {
-	case <-ch:
-	case <-time.After(5 * time.Second):
-		t.Error("Timed out waiting for CheckTx callback")
-	}
+		// wait for tx to arrive in mempoool.
+		select {
+		case <-ch:
+		case <-time.After(5 * time.Second):
+			t.Error("Timed out waiting for CheckTx callback")
+		}
 
-	mempoolSize := pool.Size()
-	for i, c := range GetClients(t, n, conf) {
-		mc, ok := c.(client.MempoolClient)
-		require.True(t, ok, "%d", i)
-		res, err := mc.NumUnconfirmedTxs(ctx)
-		require.Nil(t, err, "%d: %+v", i, err)
-
-		assert.Equal(t, mempoolSize, res.Count)
-		assert.Equal(t, mempoolSize, res.Total)
-		assert.Equal(t, pool.SizeBytes(), res.TotalBytes)
-	}
+		for _, c := range GetClients(t, n, conf) {
+			mc := c.(client.MempoolClient)
+			limit := 1
+			res, err := mc.UnconfirmedTxs(ctx, &limit)
+			require.NoError(t, err)
 
-	pool.Flush()
-}
+			assert.Equal(t, 1, res.Count)
+			assert.Equal(t, 1, res.Total)
+			assert.Equal(t, pool.SizeBytes(), res.TotalBytes)
+			assert.Exactly(t, types.Txs{tx}, types.Txs(res.Txs))
+		}
 
-func TestCheckTx(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+		pool.Flush()
+	})
+	t.Run("NumUnconfirmedTxs", func(t *testing.T) {
+		ch := make(chan struct{})
 
-	n, conf := NodeSuite(t)
-	pool := getMempool(t, n)
+		pool := getMempool(t, n)
 
-	for _, c := range GetClients(t, n, conf) {
 		_, _, tx := MakeTxKV()
 
-		res, err := c.CheckTx(ctx, tx)
+		err := pool.CheckTx(ctx, tx, func(_ *abci.Response) { close(ch) }, mempool.TxInfo{})
 		require.NoError(t, err)
-		assert.Equal(t, abci.CodeTypeOK, res.Code)
 
-		assert.Equal(t, 0, pool.Size(), "mempool must be empty")
-	}
-}
-
-func TestTx(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	n, conf := NodeSuite(t)
+		// wait for tx to arrive in mempoool.
+		select {
+		case <-ch:
+		case <-time.After(5 * time.Second):
+			t.Error("Timed out waiting for CheckTx callback")
+		}
 
-	c := getHTTPClient(t, conf)
-
-	// first we broadcast a tx
-	_, _, tx := MakeTxKV()
-	bres, err := c.BroadcastTxCommit(ctx, tx)
-	require.Nil(t, err, "%+v", err)
-
-	txHeight := bres.Height
-	txHash := bres.Hash
-
-	anotherTxHash := types.Tx("a different tx").Hash()
-
-	cases := []struct {
-		valid bool
-		prove bool
-		hash  []byte
-	}{
-		// only valid if correct hash provided
-		{true, false, txHash},
-		{true, true, txHash},
-		{false, false, anotherTxHash},
-		{false, true, anotherTxHash},
-		{false, false, nil},
-		{false, true, nil},
-	}
+		mempoolSize := pool.Size()
+		for i, c := range GetClients(t, n, conf) {
+			mc, ok := c.(client.MempoolClient)
+			require.True(t, ok, "%d", i)
+			res, err := mc.NumUnconfirmedTxs(ctx)
+			require.Nil(t, err, "%d: %+v", i, err)
 
-	for i, c := range GetClients(t, n, conf) {
-		for j, tc := range cases {
-			t.Logf("client %d, case %d", i, j)
+			assert.Equal(t, mempoolSize, res.Count)
+			assert.Equal(t, mempoolSize, res.Total)
+			assert.Equal(t, pool.SizeBytes(), res.TotalBytes)
+		}
 
-			// now we query for the tx.
-			// since there's only one tx, we know index=0.
-			ptx, err := c.Tx(ctx, tc.hash, tc.prove)
+		pool.Flush()
+	})
+	t.Run("Tx", func(t *testing.T) {
+		c := getHTTPClient(t, conf)
 
-			if !tc.valid {
-				require.NotNil(t, err)
-			} else {
-				require.Nil(t, err, "%+v", err)
-				assert.EqualValues(t, txHeight, ptx.Height)
-				assert.EqualValues(t, tx, ptx.Tx)
-				assert.Zero(t, ptx.Index)
-				assert.True(t, ptx.TxResult.IsOK())
-				assert.EqualValues(t, txHash, ptx.Hash)
+		// first we broadcast a tx
+		_, _, tx := MakeTxKV()
+		bres, err := c.BroadcastTxCommit(ctx, tx)
+		require.Nil(t, err, "%+v", err)
+
+		txHeight := bres.Height
+		txHash := bres.Hash
+
+		anotherTxHash := types.Tx("a different tx").Hash()
+
+		cases := []struct {
+			valid bool
+			prove bool
+			hash  []byte
+		}{
+			// only valid if correct hash provided
+			{true, false, txHash},
+			{true, true, txHash},
+			{false, false, anotherTxHash},
+			{false, true, anotherTxHash},
+			{false, false, nil},
+			{false, true, nil},
+		}
 
-				// time to verify the proof
-				proof := ptx.Proof
-				if tc.prove && assert.EqualValues(t, tx, proof.Data) {
-					assert.NoError(t, proof.Proof.Verify(proof.RootHash, txHash))
+		for _, c := range GetClients(t, n, conf) {
+			t.Run(fmt.Sprintf("%T", c), func(t *testing.T) {
+				for j, tc := range cases {
+					t.Run(fmt.Sprintf("Case%d", j), func(t *testing.T) {
+						// now we query for the tx.
+						// since there's only one tx, we know index=0.
+						ptx, err := c.Tx(ctx, tc.hash, tc.prove)
+
+						if !tc.valid {
+							require.NotNil(t, err)
+						} else {
+							require.Nil(t, err, "%+v", err)
+							assert.EqualValues(t, txHeight, ptx.Height)
+							assert.EqualValues(t, tx, ptx.Tx)
+							assert.Zero(t, ptx.Index)
+							assert.True(t, ptx.TxResult.IsOK())
+							assert.EqualValues(t, txHash, ptx.Hash)
+
+							// time to verify the proof
+							proof := ptx.Proof
+							if tc.prove && assert.EqualValues(t, tx, proof.Data) {
+								assert.NoError(t, proof.Proof.Verify(proof.RootHash, txHash))
+							}
+						}
+					})
 				}
-			}
+			})
 		}
-	}
-}
-
-func TestTxSearchWithTimeout(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, conf := NodeSuite(t)
-	timeoutClient := getHTTPClientWithTimeout(t, conf, 10*time.Second)
-
-	_, _, tx := MakeTxKV()
-	_, err := timeoutClient.BroadcastTxCommit(ctx, tx)
-	require.NoError(t, err)
-
-	// query using a compositeKey (see kvstore application)
-	result, err := timeoutClient.TxSearch(ctx, "app.creator='Cosmoshi Netowoko'", false, nil, nil, "asc")
-	require.Nil(t, err)
-	require.Greater(t, len(result.Txs), 0, "expected a lot of transactions")
-}
-
-func TestTxSearch(t *testing.T) {
-	n, conf := NodeSuite(t)
-	c := getHTTPClient(t, conf)
+	})
+	t.Run("TxSearchWithTimeout", func(t *testing.T) {
+		timeoutClient := getHTTPClientWithTimeout(t, conf, 10*time.Second)
 
-	// first we broadcast a few txs
-	for i := 0; i < 10; i++ {
 		_, _, tx := MakeTxKV()
-		_, err := c.BroadcastTxCommit(context.Background(), tx)
+		_, err := timeoutClient.BroadcastTxCommit(ctx, tx)
 		require.NoError(t, err)
-	}
-
-	// since we're not using an isolated test server, we'll have lingering transactions
-	// from other tests as well
-	result, err := c.TxSearch(context.Background(), "tx.height >= 0", true, nil, nil, "asc")
-	require.NoError(t, err)
-	txCount := len(result.Txs)
-
-	// pick out the last tx to have something to search for in tests
-	find := result.Txs[len(result.Txs)-1]
-	anotherTxHash := types.Tx("a different tx").Hash()
-
-	for i, c := range GetClients(t, n, conf) {
-		t.Logf("client %d", i)
-
-		// now we query for the tx.
-		result, err := c.TxSearch(context.Background(), fmt.Sprintf("tx.hash='%v'", find.Hash), true, nil, nil, "asc")
-		require.Nil(t, err)
-		require.Len(t, result.Txs, 1)
-		require.Equal(t, find.Hash, result.Txs[0].Hash)
-
-		ptx := result.Txs[0]
-		assert.EqualValues(t, find.Height, ptx.Height)
-		assert.EqualValues(t, find.Tx, ptx.Tx)
-		assert.Zero(t, ptx.Index)
-		assert.True(t, ptx.TxResult.IsOK())
-		assert.EqualValues(t, find.Hash, ptx.Hash)
-
-		// time to verify the proof
-		if assert.EqualValues(t, find.Tx, ptx.Proof.Data) {
-			assert.NoError(t, ptx.Proof.Proof.Verify(ptx.Proof.RootHash, find.Hash))
-		}
-
-		// query by height
-		result, err = c.TxSearch(context.Background(), fmt.Sprintf("tx.height=%d", find.Height), true, nil, nil, "asc")
-		require.Nil(t, err)
-		require.Len(t, result.Txs, 1)
-
-		// query for non existing tx
-		result, err = c.TxSearch(context.Background(), fmt.Sprintf("tx.hash='%X'", anotherTxHash), false, nil, nil, "asc")
-		require.Nil(t, err)
-		require.Len(t, result.Txs, 0)
 
 		// query using a compositeKey (see kvstore application)
-		result, err = c.TxSearch(context.Background(), "app.creator='Cosmoshi Netowoko'", false, nil, nil, "asc")
+		result, err := timeoutClient.TxSearch(ctx, "app.creator='Cosmoshi Netowoko'", false, nil, nil, "asc")
 		require.Nil(t, err)
 		require.Greater(t, len(result.Txs), 0, "expected a lot of transactions")
+	})
+	t.Run("TxSearch", func(t *testing.T) {
+		t.Skip("Test Asserts Non-Deterministic Results")
+		c := getHTTPClient(t, conf)
+
+		// first we broadcast a few txs
+		for i := 0; i < 10; i++ {
+			_, _, tx := MakeTxKV()
+			_, err := c.BroadcastTxSync(ctx, tx)
+			require.NoError(t, err)
+		}
 
-		// query using an index key
-		result, err = c.TxSearch(context.Background(), "app.index_key='index is working'", false, nil, nil, "asc")
-		require.Nil(t, err)
-		require.Greater(t, len(result.Txs), 0, "expected a lot of transactions")
+		// since we're not using an isolated test server, we'll have lingering transactions
+		// from other tests as well
+		result, err := c.TxSearch(ctx, "tx.height >= 0", true, nil, nil, "asc")
+		require.NoError(t, err)
+		txCount := len(result.Txs)
 
-		// query using an noindex key
-		result, err = c.TxSearch(context.Background(), "app.noindex_key='index is working'", false, nil, nil, "asc")
-		require.Nil(t, err)
-		require.Equal(t, len(result.Txs), 0, "expected a lot of transactions")
+		// pick out the last tx to have something to search for in tests
+		find := result.Txs[len(result.Txs)-1]
+		anotherTxHash := types.Tx("a different tx").Hash()
 
-		// query using a compositeKey (see kvstore application) and height
-		result, err = c.TxSearch(context.Background(),
-			"app.creator='Cosmoshi Netowoko' AND tx.height<10000", true, nil, nil, "asc")
-		require.Nil(t, err)
-		require.Greater(t, len(result.Txs), 0, "expected a lot of transactions")
+		for _, c := range GetClients(t, n, conf) {
+			t.Run(fmt.Sprintf("%T", c), func(t *testing.T) {
 
-		// query a non existing tx with page 1 and txsPerPage 1
-		perPage := 1
-		result, err = c.TxSearch(context.Background(), "app.creator='Cosmoshi Neetowoko'", true, nil, &perPage, "asc")
-		require.Nil(t, err)
-		require.Len(t, result.Txs, 0)
+				// now we query for the tx.
+				result, err := c.TxSearch(ctx, fmt.Sprintf("tx.hash='%v'", find.Hash), true, nil, nil, "asc")
+				require.Nil(t, err)
+				require.Len(t, result.Txs, 1)
+				require.Equal(t, find.Hash, result.Txs[0].Hash)
 
-		// check sorting
-		result, err = c.TxSearch(context.Background(), "tx.height >= 1", false, nil, nil, "asc")
-		require.Nil(t, err)
-		for k := 0; k < len(result.Txs)-1; k++ {
-			require.LessOrEqual(t, result.Txs[k].Height, result.Txs[k+1].Height)
-			require.LessOrEqual(t, result.Txs[k].Index, result.Txs[k+1].Index)
-		}
+				ptx := result.Txs[0]
+				assert.EqualValues(t, find.Height, ptx.Height)
+				assert.EqualValues(t, find.Tx, ptx.Tx)
+				assert.Zero(t, ptx.Index)
+				assert.True(t, ptx.TxResult.IsOK())
+				assert.EqualValues(t, find.Hash, ptx.Hash)
 
-		result, err = c.TxSearch(context.Background(), "tx.height >= 1", false, nil, nil, "desc")
-		require.Nil(t, err)
-		for k := 0; k < len(result.Txs)-1; k++ {
-			require.GreaterOrEqual(t, result.Txs[k].Height, result.Txs[k+1].Height)
-			require.GreaterOrEqual(t, result.Txs[k].Index, result.Txs[k+1].Index)
-		}
-		// check pagination
-		perPage = 3
-		var (
-			seen      = map[int64]bool{}
-			maxHeight int64
-			pages     = int(math.Ceil(float64(txCount) / float64(perPage)))
-		)
-
-		for page := 1; page <= pages; page++ {
-			page := page
-			result, err := c.TxSearch(context.Background(), "tx.height >= 1", false, &page, &perPage, "asc")
-			require.NoError(t, err)
-			if page < pages {
-				require.Len(t, result.Txs, perPage)
-			} else {
-				require.LessOrEqual(t, len(result.Txs), perPage)
-			}
-			require.Equal(t, txCount, result.TotalCount)
-			for _, tx := range result.Txs {
-				require.False(t, seen[tx.Height],
-					"Found duplicate height %v in page %v", tx.Height, page)
-				require.Greater(t, tx.Height, maxHeight,
-					"Found decreasing height %v (max seen %v) in page %v", tx.Height, maxHeight, page)
-				seen[tx.Height] = true
-				maxHeight = tx.Height
-			}
-		}
-		require.Len(t, seen, txCount)
-	}
-}
+				// time to verify the proof
+				if assert.EqualValues(t, find.Tx, ptx.Proof.Data) {
+					assert.NoError(t, ptx.Proof.Proof.Verify(ptx.Proof.RootHash, find.Hash))
+				}
 
-func TestBatchedJSONRPCCalls(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+				// query by height
+				result, err = c.TxSearch(ctx, fmt.Sprintf("tx.height=%d", find.Height), true, nil, nil, "asc")
+				require.Nil(t, err)
+				require.Len(t, result.Txs, 1)
+
+				// query for non existing tx
+				result, err = c.TxSearch(ctx, fmt.Sprintf("tx.hash='%X'", anotherTxHash), false, nil, nil, "asc")
+				require.Nil(t, err)
+				require.Len(t, result.Txs, 0)
+
+				// query using a compositeKey (see kvstore application)
+				result, err = c.TxSearch(ctx, "app.creator='Cosmoshi Netowoko'", false, nil, nil, "asc")
+				require.Nil(t, err)
+				require.Greater(t, len(result.Txs), 0, "expected a lot of transactions")
+
+				// query using an index key
+				result, err = c.TxSearch(ctx, "app.index_key='index is working'", false, nil, nil, "asc")
+				require.Nil(t, err)
+				require.Greater(t, len(result.Txs), 0, "expected a lot of transactions")
+
+				// query using an noindex key
+				result, err = c.TxSearch(ctx, "app.noindex_key='index is working'", false, nil, nil, "asc")
+				require.Nil(t, err)
+				require.Equal(t, len(result.Txs), 0, "expected a lot of transactions")
+
+				// query using a compositeKey (see kvstore application) and height
+				result, err = c.TxSearch(ctx,
+					"app.creator='Cosmoshi Netowoko' AND tx.height<10000", true, nil, nil, "asc")
+				require.Nil(t, err)
+				require.Greater(t, len(result.Txs), 0, "expected a lot of transactions")
+
+				// query a non existing tx with page 1 and txsPerPage 1
+				perPage := 1
+				result, err = c.TxSearch(ctx, "app.creator='Cosmoshi Neetowoko'", true, nil, &perPage, "asc")
+				require.Nil(t, err)
+				require.Len(t, result.Txs, 0)
+
+				// check sorting
+				result, err = c.TxSearch(ctx, "tx.height >= 1", false, nil, nil, "asc")
+				require.Nil(t, err)
+				for k := 0; k < len(result.Txs)-1; k++ {
+					require.LessOrEqual(t, result.Txs[k].Height, result.Txs[k+1].Height)
+					require.LessOrEqual(t, result.Txs[k].Index, result.Txs[k+1].Index)
+				}
 
-	_, conf := NodeSuite(t)
-	c := getHTTPClient(t, conf)
-	testBatchedJSONRPCCalls(ctx, t, c)
+				result, err = c.TxSearch(ctx, "tx.height >= 1", false, nil, nil, "desc")
+				require.Nil(t, err)
+				for k := 0; k < len(result.Txs)-1; k++ {
+					require.GreaterOrEqual(t, result.Txs[k].Height, result.Txs[k+1].Height)
+					require.GreaterOrEqual(t, result.Txs[k].Index, result.Txs[k+1].Index)
+				}
+				// check pagination
+				perPage = 3
+				var (
+					seen      = map[int64]bool{}
+					maxHeight int64
+					pages     = int(math.Ceil(float64(txCount) / float64(perPage)))
+				)
+
+				for page := 1; page <= pages; page++ {
+					page := page
+					result, err := c.TxSearch(ctx, "tx.height >= 1", false, &page, &perPage, "asc")
+					require.NoError(t, err)
+					if page < pages {
+						require.Len(t, result.Txs, perPage)
+					} else {
+						require.LessOrEqual(t, len(result.Txs), perPage)
+					}
+					require.Equal(t, txCount, result.TotalCount)
+					for _, tx := range result.Txs {
+						require.False(t, seen[tx.Height],
+							"Found duplicate height %v in page %v", tx.Height, page)
+						require.Greater(t, tx.Height, maxHeight,
+							"Found decreasing height %v (max seen %v) in page %v", tx.Height, maxHeight, page)
+						seen[tx.Height] = true
+						maxHeight = tx.Height
+					}
+				}
+				require.Len(t, seen, txCount)
+			})
+		}
+	})
 }
 
 func testBatchedJSONRPCCalls(ctx context.Context, t *testing.T, c *rpchttp.HTTP) {
@@ -814,60 +828,3 @@ func testBatchedJSONRPCCalls(ctx context.Context, t *testing.T, c *rpchttp.HTTP)
 	require.Equal(t, qresult1.Response.Value, v1)
 	require.Equal(t, qresult2.Response.Value, v2)
 }
-
-func TestBatchedJSONRPCCallsCancellation(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, conf := NodeSuite(t)
-	c := getHTTPClient(t, conf)
-	_, _, tx1 := MakeTxKV()
-	_, _, tx2 := MakeTxKV()
-
-	batch := c.NewBatch()
-	_, err := batch.BroadcastTxCommit(ctx, tx1)
-	require.NoError(t, err)
-	_, err = batch.BroadcastTxCommit(ctx, tx2)
-	require.NoError(t, err)
-	// we should have 2 requests waiting
-	require.Equal(t, 2, batch.Count())
-	// we want to make sure we cleared 2 pending requests
-	require.Equal(t, 2, batch.Clear())
-	// now there should be no batched requests
-	require.Equal(t, 0, batch.Count())
-}
-
-func TestSendingEmptyRequestBatch(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, conf := NodeSuite(t)
-	c := getHTTPClient(t, conf)
-	batch := c.NewBatch()
-	_, err := batch.Send(ctx)
-	require.Error(t, err, "sending an empty batch of JSON RPC requests should result in an error")
-}
-
-func TestClearingEmptyRequestBatch(t *testing.T) {
-	_, conf := NodeSuite(t)
-	c := getHTTPClient(t, conf)
-	batch := c.NewBatch()
-	require.Zero(t, batch.Clear(), "clearing an empty batch of JSON RPC requests should result in a 0 result")
-}
-
-func TestConcurrentJSONRPCBatching(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	_, conf := NodeSuite(t)
-	var wg sync.WaitGroup
-	c := getHTTPClient(t, conf)
-	for i := 0; i < 50; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			testBatchedJSONRPCCalls(ctx, t, c)
-		}()
-	}
-	wg.Wait()
-}
diff --git a/rpc/jsonrpc/client/http_json_client.go b/rpc/jsonrpc/client/http_json_client.go
index 9c73b8a8c7..7733eb00cd 100644
--- a/rpc/jsonrpc/client/http_json_client.go
+++ b/rpc/jsonrpc/client/http_json_client.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io/ioutil"
 	"net"
@@ -155,7 +156,7 @@ func New(remote string) (*Client, error) {
 // panics when client is nil.
 func NewWithHTTPClient(remote string, c *http.Client) (*Client, error) {
 	if c == nil {
-		panic("nil http.Client")
+		return nil, errors.New("nil client")
 	}
 
 	parsedURL, err := newParsedURL(remote)

From 4781d04d1808cc428e259915d5f820ef785f1d24 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Tue, 12 Oct 2021 17:40:59 -0400
Subject: [PATCH 41/57] node: always close database engine (#7113)

---
 internal/state/indexer/sink/kv/kv.go |  12 +--
 node/node.go                         | 114 ++++++++++++++++++++-------
 node/node_test.go                    |   8 +-
 node/setup.go                        |  71 +++++++++++++----
 4 files changed, 153 insertions(+), 52 deletions(-)

diff --git a/internal/state/indexer/sink/kv/kv.go b/internal/state/indexer/sink/kv/kv.go
index 4c471b4d33..fe7068a1b6 100644
--- a/internal/state/indexer/sink/kv/kv.go
+++ b/internal/state/indexer/sink/kv/kv.go
@@ -18,14 +18,16 @@ var _ indexer.EventSink = (*EventSink)(nil)
 // The EventSink is an aggregator for redirecting the call path of the tx/block kvIndexer.
 // For the implementation details please see the kv.go in the indexer/block and indexer/tx folder.
 type EventSink struct {
-	txi *kvt.TxIndex
-	bi  *kvb.BlockerIndexer
+	txi   *kvt.TxIndex
+	bi    *kvb.BlockerIndexer
+	store dbm.DB
 }
 
 func NewEventSink(store dbm.DB) indexer.EventSink {
 	return &EventSink{
-		txi: kvt.NewTxIndex(store),
-		bi:  kvb.New(store),
+		txi:   kvt.NewTxIndex(store),
+		bi:    kvb.New(store),
+		store: store,
 	}
 }
 
@@ -58,5 +60,5 @@ func (kves *EventSink) HasBlock(h int64) (bool, error) {
 }
 
 func (kves *EventSink) Stop() error {
-	return nil
+	return kves.store.Close()
 }
diff --git a/node/node.go b/node/node.go
index 6092f4c43c..6ee0d30f98 100644
--- a/node/node.go
+++ b/node/node.go
@@ -23,6 +23,7 @@ import (
 	"github.com/tendermint/tendermint/internal/proxy"
 	rpccore "github.com/tendermint/tendermint/internal/rpc/core"
 	sm "github.com/tendermint/tendermint/internal/state"
+	"github.com/tendermint/tendermint/internal/state/indexer"
 	"github.com/tendermint/tendermint/internal/statesync"
 	"github.com/tendermint/tendermint/internal/store"
 	"github.com/tendermint/tendermint/libs/log"
@@ -62,6 +63,7 @@ type nodeImpl struct {
 
 	// services
 	eventBus         *types.EventBus // pub/sub for services
+	eventSinks       []indexer.EventSink
 	stateStore       sm.Store
 	blockStore       *store.BlockStore // store the blockchain to disk
 	bcReactor        service.Service   // for block-syncing
@@ -73,6 +75,7 @@ type nodeImpl struct {
 	pexReactor       service.Service    // for exchanging peer addresses
 	evidenceReactor  service.Service
 	rpcListeners     []net.Listener // rpc servers
+	shutdownOps      closer
 	indexerService   service.Service
 	rpcEnv           *rpccore.Environment
 	prometheusSrv    *http.Server
@@ -106,6 +109,7 @@ func newDefaultNode(cfg *config.Config, logger log.Logger) (service.Service, err
 	}
 
 	appClient, _ := proxy.DefaultClientCreator(cfg.ProxyApp, cfg.ABCI, cfg.DBDir())
+
 	return makeNode(cfg,
 		pval,
 		nodeKey,
@@ -123,33 +127,41 @@ func makeNode(cfg *config.Config,
 	clientCreator abciclient.Creator,
 	genesisDocProvider genesisDocProvider,
 	dbProvider config.DBProvider,
-	logger log.Logger) (service.Service, error) {
+	logger log.Logger,
+) (service.Service, error) {
+	closers := []closer{}
 
-	blockStore, stateDB, err := initDBs(cfg, dbProvider)
+	blockStore, stateDB, dbCloser, err := initDBs(cfg, dbProvider)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, dbCloser)
 	}
+	closers = append(closers, dbCloser)
+
 	stateStore := sm.NewStore(stateDB)
 
 	genDoc, err := genesisDocProvider()
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
 	}
 
 	err = genDoc.ValidateAndComplete()
 	if err != nil {
-		return nil, fmt.Errorf("error in genesis doc: %w", err)
+		return nil, combineCloseError(
+			fmt.Errorf("error in genesis doc: %w", err),
+			makeCloser(closers))
 	}
 
 	state, err := loadStateFromDBOrGenesisDocProvider(stateStore, genDoc)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
+
 	}
 
 	// Create the proxyApp and establish connections to the ABCI app (consensus, mempool, query).
 	proxyApp, err := createAndStartProxyAppConns(clientCreator, logger)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
+
 	}
 
 	// EventBus and IndexerService must be started before the handshake because
@@ -158,12 +170,13 @@ func makeNode(cfg *config.Config,
 	// but before it indexed the txs, or, endblocker panicked)
 	eventBus, err := createAndStartEventBus(logger)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
+
 	}
 
 	indexerService, eventSinks, err := createAndStartIndexerService(cfg, dbProvider, eventBus, logger, genDoc.ChainID)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
 	}
 
 	// If an address is provided, listen on the socket for a connection from an
@@ -175,12 +188,16 @@ func makeNode(cfg *config.Config,
 		case "grpc":
 			privValidator, err = createAndStartPrivValidatorGRPCClient(cfg, genDoc.ChainID, logger)
 			if err != nil {
-				return nil, fmt.Errorf("error with private validator grpc client: %w", err)
+				return nil, combineCloseError(
+					fmt.Errorf("error with private validator grpc client: %w", err),
+					makeCloser(closers))
 			}
 		default:
 			privValidator, err = createAndStartPrivValidatorSocketClient(cfg.PrivValidator.ListenAddr, genDoc.ChainID, logger)
 			if err != nil {
-				return nil, fmt.Errorf("error with private validator socket client: %w", err)
+				return nil, combineCloseError(
+					fmt.Errorf("error with private validator socket client: %w", err),
+					makeCloser(closers))
 			}
 		}
 	}
@@ -188,10 +205,14 @@ func makeNode(cfg *config.Config,
 	if cfg.Mode == config.ModeValidator {
 		pubKey, err = privValidator.GetPubKey(context.TODO())
 		if err != nil {
-			return nil, fmt.Errorf("can't get pubkey: %w", err)
+			return nil, combineCloseError(fmt.Errorf("can't get pubkey: %w", err),
+				makeCloser(closers))
+
 		}
 		if pubKey == nil {
-			return nil, errors.New("could not retrieve public key from private validator")
+			return nil, combineCloseError(
+				errors.New("could not retrieve public key from private validator"),
+				makeCloser(closers))
 		}
 	}
 
@@ -207,7 +228,8 @@ func makeNode(cfg *config.Config,
 	consensusLogger := logger.With("module", "consensus")
 	if !stateSync {
 		if err := doHandshake(stateStore, state, blockStore, genDoc, eventBus, proxyApp, consensusLogger); err != nil {
-			return nil, err
+			return nil, combineCloseError(err, makeCloser(closers))
+
 		}
 
 		// Reload the state. It will have the Version.Consensus.App set by the
@@ -215,7 +237,9 @@ func makeNode(cfg *config.Config,
 		// what happened during block replay).
 		state, err = stateStore.Load()
 		if err != nil {
-			return nil, fmt.Errorf("cannot load state: %w", err)
+			return nil, combineCloseError(
+				fmt.Errorf("cannot load state: %w", err),
+				makeCloser(closers))
 		}
 	}
 
@@ -229,38 +253,45 @@ func makeNode(cfg *config.Config,
 	// TODO: Use a persistent peer database.
 	nodeInfo, err := makeNodeInfo(cfg, nodeKey, eventSinks, genDoc, state)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
+
 	}
 
 	p2pLogger := logger.With("module", "p2p")
 	transport := createTransport(p2pLogger, cfg)
 
-	peerManager, err := createPeerManager(cfg, dbProvider, nodeKey.ID)
+	peerManager, peerCloser, err := createPeerManager(cfg, dbProvider, nodeKey.ID)
+	closers = append(closers, peerCloser)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create peer manager: %w", err)
+		return nil, combineCloseError(
+			fmt.Errorf("failed to create peer manager: %w", err),
+			makeCloser(closers))
 	}
 
-	nodeMetrics :=
-		defaultMetricsProvider(cfg.Instrumentation)(genDoc.ChainID)
+	nodeMetrics := defaultMetricsProvider(cfg.Instrumentation)(genDoc.ChainID)
 
 	router, err := createRouter(p2pLogger, nodeMetrics.p2p, nodeInfo, nodeKey.PrivKey,
 		peerManager, transport, getRouterConfig(cfg, proxyApp))
 	if err != nil {
-		return nil, fmt.Errorf("failed to create router: %w", err)
+		return nil, combineCloseError(
+			fmt.Errorf("failed to create router: %w", err),
+			makeCloser(closers))
 	}
 
 	mpReactorShim, mpReactor, mp, err := createMempoolReactor(
 		cfg, proxyApp, state, nodeMetrics.mempool, peerManager, router, logger,
 	)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
+
 	}
 
 	evReactorShim, evReactor, evPool, err := createEvidenceReactor(
 		cfg, dbProvider, stateDB, blockStore, peerManager, router, logger,
 	)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
+
 	}
 
 	// make block executor for consensus and blockchain reactors to execute blocks
@@ -287,7 +318,9 @@ func makeNode(cfg *config.Config,
 		peerManager, router, blockSync && !stateSync, nodeMetrics.consensus,
 	)
 	if err != nil {
-		return nil, fmt.Errorf("could not create blockchain reactor: %w", err)
+		return nil, combineCloseError(
+			fmt.Errorf("could not create blockchain reactor: %w", err),
+			makeCloser(closers))
 	}
 
 	// Make ConsensusReactor. Don't enable fully if doing a state sync and/or block sync first.
@@ -305,6 +338,7 @@ func makeNode(cfg *config.Config,
 	ssLogger := logger.With("module", "statesync")
 	ssReactorShim := p2p.NewReactorShim(ssLogger, "StateSyncShim", statesync.ChannelShims)
 	channels := makeChannelsFromShims(router, statesync.ChannelShims)
+
 	peerUpdates := peerManager.Subscribe()
 	stateSyncReactor := statesync.NewReactor(
 		genDoc.ChainID,
@@ -354,7 +388,8 @@ func makeNode(cfg *config.Config,
 
 	pexReactor, err = createPEXReactor(logger, peerManager, router)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, makeCloser(closers))
+
 	}
 
 	if cfg.RPC.PprofListenAddress != "" {
@@ -387,6 +422,9 @@ func makeNode(cfg *config.Config,
 		evidenceReactor:  evReactor,
 		indexerService:   indexerService,
 		eventBus:         eventBus,
+		eventSinks:       eventSinks,
+
+		shutdownOps: makeCloser(closers),
 
 		rpcEnv: &rpccore.Environment{
 			ProxyAppQuery:   proxyApp.Query(),
@@ -434,6 +472,7 @@ func makeSeedNode(cfg *config.Config,
 	state, err := sm.MakeGenesisState(genDoc)
 	if err != nil {
 		return nil, err
+
 	}
 
 	nodeInfo, err := makeSeedNodeInfo(cfg, nodeKey, genDoc, state)
@@ -446,15 +485,19 @@ func makeSeedNode(cfg *config.Config,
 	p2pLogger := logger.With("module", "p2p")
 	transport := createTransport(p2pLogger, cfg)
 
-	peerManager, err := createPeerManager(cfg, dbProvider, nodeKey.ID)
+	peerManager, closer, err := createPeerManager(cfg, dbProvider, nodeKey.ID)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create peer manager: %w", err)
+		return nil, combineCloseError(
+			fmt.Errorf("failed to create peer manager: %w", err),
+			closer)
 	}
 
 	router, err := createRouter(p2pLogger, p2pMetrics, nodeInfo, nodeKey.PrivKey,
 		peerManager, transport, getRouterConfig(cfg, nil))
 	if err != nil {
-		return nil, fmt.Errorf("failed to create router: %w", err)
+		return nil, combineCloseError(
+			fmt.Errorf("failed to create router: %w", err),
+			closer)
 	}
 
 	var pexReactor service.Service
@@ -468,7 +511,8 @@ func makeSeedNode(cfg *config.Config,
 
 	pexReactor, err = createPEXReactor(logger, peerManager, router)
 	if err != nil {
-		return nil, err
+		return nil, combineCloseError(err, closer)
+
 	}
 
 	if cfg.RPC.PprofListenAddress != "" {
@@ -488,6 +532,8 @@ func makeSeedNode(cfg *config.Config,
 		peerManager: peerManager,
 		router:      router,
 
+		shutdownOps: closer,
+
 		pexReactor: pexReactor,
 	}
 	node.BaseService = *service.NewBaseService(logger, "SeedNode", node)
@@ -653,6 +699,12 @@ func (n *nodeImpl) OnStop() {
 		}
 	}
 
+	for _, es := range n.eventSinks {
+		if err := es.Stop(); err != nil {
+			n.Logger.Error("failed to stop event sink", "err", err)
+		}
+	}
+
 	if n.config.Mode != config.ModeSeed {
 		// now stop the reactors
 		if n.config.BlockSync.Enable {
@@ -716,6 +768,10 @@ func (n *nodeImpl) OnStop() {
 			// Error from closing listeners, or context timeout:
 			n.Logger.Error("Prometheus HTTP server Shutdown", "err", err)
 		}
+
+	}
+	if err := n.shutdownOps(); err != nil {
+		n.Logger.Error("problem shutting down additional services", "err", err)
 	}
 }
 
diff --git a/node/node_test.go b/node/node_test.go
index d5ea39aa67..7039b09e18 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -592,7 +592,7 @@ func TestNodeSetEventSink(t *testing.T) {
 	cfg.TxIndex.Indexer = []string{"kvv"}
 	ns, err := newDefaultNode(cfg, logger)
 	assert.Nil(t, ns)
-	assert.Equal(t, errors.New("unsupported event sink type"), err)
+	assert.Contains(t, err.Error(), "unsupported event sink type")
 	t.Cleanup(cleanup(ns))
 
 	cfg.TxIndex.Indexer = []string{}
@@ -604,7 +604,7 @@ func TestNodeSetEventSink(t *testing.T) {
 	cfg.TxIndex.Indexer = []string{"psql"}
 	ns, err = newDefaultNode(cfg, logger)
 	assert.Nil(t, ns)
-	assert.Equal(t, errors.New("the psql connection settings cannot be empty"), err)
+	assert.Contains(t, err.Error(), "the psql connection settings cannot be empty")
 	t.Cleanup(cleanup(ns))
 
 	var psqlConn = "test"
@@ -646,14 +646,14 @@ func TestNodeSetEventSink(t *testing.T) {
 	cfg.TxIndex.PsqlConn = psqlConn
 	ns, err = newDefaultNode(cfg, logger)
 	require.Error(t, err)
-	assert.Equal(t, e, err)
+	assert.Contains(t, err.Error(), e.Error())
 	t.Cleanup(cleanup(ns))
 
 	cfg.TxIndex.Indexer = []string{"Psql", "kV", "kv", "pSql"}
 	cfg.TxIndex.PsqlConn = psqlConn
 	ns, err = newDefaultNode(cfg, logger)
 	require.Error(t, err)
-	assert.Equal(t, e, err)
+	assert.Contains(t, err.Error(), e.Error())
 	t.Cleanup(cleanup(ns))
 }
 
diff --git a/node/setup.go b/node/setup.go
index f6b9c028de..ac36b08582 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -2,7 +2,9 @@ package node
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
+	"strings"
 	"time"
 
 	dbm "github.com/tendermint/tm-db"
@@ -35,16 +37,57 @@ import (
 	_ "net/http/pprof" // nolint: gosec // securely exposed on separate, optional port
 )
 
-func initDBs(cfg *config.Config, dbProvider config.DBProvider) (blockStore *store.BlockStore, stateDB dbm.DB, err error) { //nolint:lll
-	var blockStoreDB dbm.DB
-	blockStoreDB, err = dbProvider(&config.DBContext{ID: "blockstore", Config: cfg})
+type closer func() error
+
+func makeCloser(cs []closer) closer {
+	return func() error {
+		errs := make([]string, 0, len(cs))
+		for _, cl := range cs {
+			if err := cl(); err != nil {
+				errs = append(errs, err.Error())
+			}
+		}
+		if len(errs) >= 0 {
+			return errors.New(strings.Join(errs, "; "))
+		}
+		return nil
+	}
+}
+
+func combineCloseError(err error, cl closer) error {
+	if err == nil {
+		return cl()
+	}
+
+	clerr := cl()
+	if clerr == nil {
+		return err
+	}
+
+	return fmt.Errorf("error=%q closerError=%q", err.Error(), clerr.Error())
+}
+
+func initDBs(
+	cfg *config.Config,
+	dbProvider config.DBProvider,
+) (*store.BlockStore, dbm.DB, closer, error) {
+
+	blockStoreDB, err := dbProvider(&config.DBContext{ID: "blockstore", Config: cfg})
 	if err != nil {
-		return
+		return nil, nil, func() error { return nil }, err
 	}
-	blockStore = store.NewBlockStore(blockStoreDB)
+	closers := []closer{}
+	blockStore := store.NewBlockStore(blockStoreDB)
+	closers = append(closers, blockStoreDB.Close)
 
-	stateDB, err = dbProvider(&config.DBContext{ID: "state", Config: cfg})
-	return
+	stateDB, err := dbProvider(&config.DBContext{ID: "state", Config: cfg})
+	if err != nil {
+		return nil, nil, makeCloser(closers), err
+	}
+
+	closers = append(closers, stateDB.Close)
+
+	return blockStore, stateDB, makeCloser(closers), nil
 }
 
 func createAndStartProxyAppConns(clientCreator abciclient.Creator, logger log.Logger) (proxy.AppConns, error) {
@@ -354,7 +397,7 @@ func createPeerManager(
 	cfg *config.Config,
 	dbProvider config.DBProvider,
 	nodeID types.NodeID,
-) (*p2p.PeerManager, error) {
+) (*p2p.PeerManager, closer, error) {
 
 	var maxConns uint16
 
@@ -385,7 +428,7 @@ func createPeerManager(
 	for _, p := range tmstrings.SplitAndTrimEmpty(cfg.P2P.PersistentPeers, ",", " ") {
 		address, err := p2p.ParseNodeAddress(p)
 		if err != nil {
-			return nil, fmt.Errorf("invalid peer address %q: %w", p, err)
+			return nil, func() error { return nil }, fmt.Errorf("invalid peer address %q: %w", p, err)
 		}
 
 		peers = append(peers, address)
@@ -395,28 +438,28 @@ func createPeerManager(
 	for _, p := range tmstrings.SplitAndTrimEmpty(cfg.P2P.BootstrapPeers, ",", " ") {
 		address, err := p2p.ParseNodeAddress(p)
 		if err != nil {
-			return nil, fmt.Errorf("invalid peer address %q: %w", p, err)
+			return nil, func() error { return nil }, fmt.Errorf("invalid peer address %q: %w", p, err)
 		}
 		peers = append(peers, address)
 	}
 
 	peerDB, err := dbProvider(&config.DBContext{ID: "peerstore", Config: cfg})
 	if err != nil {
-		return nil, err
+		return nil, func() error { return nil }, err
 	}
 
 	peerManager, err := p2p.NewPeerManager(nodeID, peerDB, options)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create peer manager: %w", err)
+		return nil, peerDB.Close, fmt.Errorf("failed to create peer manager: %w", err)
 	}
 
 	for _, peer := range peers {
 		if _, err := peerManager.Add(peer); err != nil {
-			return nil, fmt.Errorf("failed to add peer %q: %w", peer, err)
+			return nil, peerDB.Close, fmt.Errorf("failed to add peer %q: %w", peer, err)
 		}
 	}
 
-	return peerManager, nil
+	return peerManager, peerDB.Close, nil
 }
 
 func createRouter(

From 6538776e6a5c9b9a378fd1424062bf854b8e2f3d Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Tue, 12 Oct 2021 15:29:06 -0700
Subject: [PATCH 42/57] build: Fix build-docker to include the full context.
 (#7114)

Fixes #7068. The build-docker rule relies on being able to run make
build-linux, but did not pull the Makefile into the build context.
There are various ways to fix this, but this was probably the smallest.
---
 Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Makefile b/Makefile
index c9b6951f4d..7f5dc677cb 100644
--- a/Makefile
+++ b/Makefile
@@ -227,13 +227,13 @@ build-docs:
 
 build-docker: build-linux
 	cp $(BUILDDIR)/tendermint DOCKER/tendermint
-	docker build --label=tendermint --tag="tendermint/tendermint" DOCKER
+	docker build --label=tendermint --tag="tendermint/tendermint" -f DOCKER/Dockerfile .
 	rm -rf DOCKER/tendermint
 .PHONY: build-docker
 
 
 ###############################################################################
-###                       Mocks 											###
+###                                Mocks                                    ###
 ###############################################################################
 
 mockery:

From 4fe0f262d4a110505cfbfde02c7d413a084d6661 Mon Sep 17 00:00:00 2001
From: Callum Waters <cmwaters19@gmail.com>
Date: Wed, 13 Oct 2021 14:28:43 +0200
Subject: [PATCH 43/57] changelog: add 0.34.14 updates (#7117)

This PR adds the 0.34.14 changes to the changelog in master
---
 CHANGELOG.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2eda330f2c..e1ef2201a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -178,6 +178,24 @@ Special thanks to external contributors on this release: @JayT106, @bipulprasad,
 - [statesync] [\#6463](https://github.com/tendermint/tendermint/pull/6463) Adds Reverse Sync feature to fetch historical light blocks after state sync in order to verify any evidence (@cmwaters)
 - [blocksync] [\#6590](https://github.com/tendermint/tendermint/pull/6590) Update the metrics during blocksync (@JayT106)
 
+## v0.34.14
+
+This release backports the `rollback` feature to allow recovery in the event of an incorrect app hash.
+
+### FEATURES
+
+- [\#6982](https://github.com/tendermint/tendermint/pull/6982) The tendermint binary now has built-in suppport for running the end-to-end test application (with state sync support) (@cmwaters).
+- [cli] [#7033](https://github.com/tendermint/tendermint/pull/7033) Add a `rollback` command to rollback to the previous tendermint state. This may be useful in the event of non-determinstic app hash or when reverting an upgrade. @cmwaters
+
+### IMPROVEMENTS
+
+- [\#7103](https://github.com/tendermint/tendermint/pull/7104) Remove IAVL dependency (backport of #6550) (@cmwaters)
+
+### BUG FIXES
+
+- [\#7057](https://github.com/tendermint/tendermint/pull/7057) Import Postgres driver support for the psql indexer (@creachadair).
+- [ABCI] [\#7110](https://github.com/tendermint/tendermint/issues/7110) Revert "change client to use multi-reader mutexes (#6873)" (@tychoish).
+
 ## v0.34.13
 
 *September 6, 2021*

From 164de918420c88e5d7f8c207c654839dd5bf06bf Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Wed, 13 Oct 2021 14:29:03 -0400
Subject: [PATCH 44/57] rpc: move evidence tests to shared fixtures (#7119)

This is follow on to the work in #7112.
---
 rpc/client/evidence_test.go | 63 -------------------------------------
 rpc/client/rpc_test.go      | 55 ++++++++++++++++++++++++++++++++
 rpc/test/helpers.go         |  1 +
 3 files changed, 56 insertions(+), 63 deletions(-)

diff --git a/rpc/client/evidence_test.go b/rpc/client/evidence_test.go
index 98b071b911..ae4e29f529 100644
--- a/rpc/client/evidence_test.go
+++ b/rpc/client/evidence_test.go
@@ -1,17 +1,12 @@
 package client_test
 
 import (
-	"bytes"
 	"context"
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/crypto/ed25519"
-	"github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	"github.com/tendermint/tendermint/privval"
@@ -113,64 +108,6 @@ func makeEvidences(
 	return correct, fakes
 }
 
-func TestBroadcastEvidence_DuplicateVoteEvidence(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, config := NodeSuite(t)
-	chainID := config.ChainID()
-
-	pv, err := privval.LoadOrGenFilePV(config.PrivValidator.KeyFile(), config.PrivValidator.StateFile())
-	require.NoError(t, err)
-
-	for i, c := range GetClients(t, n, config) {
-		correct, fakes := makeEvidences(t, pv, chainID)
-		t.Logf("client %d", i)
-
-		// make sure that the node has produced enough blocks
-		waitForBlock(ctx, t, c, 2)
-
-		result, err := c.BroadcastEvidence(ctx, correct)
-		require.NoError(t, err, "BroadcastEvidence(%s) failed", correct)
-		assert.Equal(t, correct.Hash(), result.Hash, "expected result hash to match evidence hash")
-
-		status, err := c.Status(ctx)
-		require.NoError(t, err)
-		err = client.WaitForHeight(c, status.SyncInfo.LatestBlockHeight+2, nil)
-		require.NoError(t, err)
-
-		ed25519pub := pv.Key.PubKey.(ed25519.PubKey)
-		rawpub := ed25519pub.Bytes()
-		result2, err := c.ABCIQuery(ctx, "/val", rawpub)
-		require.NoError(t, err)
-		qres := result2.Response
-		require.True(t, qres.IsOK())
-
-		var v abci.ValidatorUpdate
-		err = abci.ReadMessage(bytes.NewReader(qres.Value), &v)
-		require.NoError(t, err, "Error reading query result, value %v", qres.Value)
-
-		pk, err := encoding.PubKeyFromProto(v.PubKey)
-		require.NoError(t, err)
-
-		require.EqualValues(t, rawpub, pk, "Stored PubKey not equal with expected, value %v", string(qres.Value))
-		require.Equal(t, int64(9), v.Power, "Stored Power not equal with expected, value %v", string(qres.Value))
-
-		for _, fake := range fakes {
-			_, err := c.BroadcastEvidence(ctx, fake)
-			require.Error(t, err, "BroadcastEvidence(%s) succeeded, but the evidence was fake", fake)
-		}
-	}
-}
-
-func TestBroadcastEmptyEvidence(t *testing.T) {
-	n, conf := NodeSuite(t)
-	for _, c := range GetClients(t, n, conf) {
-		_, err := c.BroadcastEvidence(context.Background(), nil)
-		assert.Error(t, err)
-	}
-}
-
 func waitForBlock(ctx context.Context, t *testing.T, c client.Client, height int64) {
 	timer := time.NewTimer(0 * time.Millisecond)
 	defer timer.Stop()
diff --git a/rpc/client/rpc_test.go b/rpc/client/rpc_test.go
index d7554d1749..38766e0478 100644
--- a/rpc/client/rpc_test.go
+++ b/rpc/client/rpc_test.go
@@ -1,6 +1,7 @@
 package client_test
 
 import (
+	"bytes"
 	"context"
 	"encoding/base64"
 	"fmt"
@@ -16,11 +17,14 @@ import (
 
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/crypto/ed25519"
+	"github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/internal/mempool"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 	"github.com/tendermint/tendermint/libs/log"
 	tmmath "github.com/tendermint/tendermint/libs/math"
 	"github.com/tendermint/tendermint/libs/service"
+	"github.com/tendermint/tendermint/privval"
 	"github.com/tendermint/tendermint/rpc/client"
 	rpchttp "github.com/tendermint/tendermint/rpc/client/http"
 	rpclocal "github.com/tendermint/tendermint/rpc/client/local"
@@ -193,8 +197,13 @@ func TestClientMethodCalls(t *testing.T) {
 	defer cancel()
 	n, conf := NodeSuite(t)
 
+	// for broadcast tx tests
 	pool := getMempool(t, n)
 
+	// for evidence tests
+	pv, err := privval.LoadOrGenFilePV(conf.PrivValidator.KeyFile(), conf.PrivValidator.StateFile())
+	require.NoError(t, err)
+
 	for i, c := range GetClients(t, n, conf) {
 		t.Run(fmt.Sprintf("%T", c), func(t *testing.T) {
 			t.Run("Status", func(t *testing.T) {
@@ -503,6 +512,52 @@ func TestClientMethodCalls(t *testing.T) {
 					testTxEventsSent(ctx, t, "sync", c)
 				})
 			})
+			t.Run("Evidence", func(t *testing.T) {
+				t.Run("BraodcastDuplicateVote", func(t *testing.T) {
+					chainID := conf.ChainID()
+
+					correct, fakes := makeEvidences(t, pv, chainID)
+
+					// make sure that the node has produced enough blocks
+					waitForBlock(ctx, t, c, 2)
+
+					result, err := c.BroadcastEvidence(ctx, correct)
+					require.NoError(t, err, "BroadcastEvidence(%s) failed", correct)
+					assert.Equal(t, correct.Hash(), result.Hash, "expected result hash to match evidence hash")
+
+					status, err := c.Status(ctx)
+					require.NoError(t, err)
+					err = client.WaitForHeight(c, status.SyncInfo.LatestBlockHeight+2, nil)
+					require.NoError(t, err)
+
+					ed25519pub := pv.Key.PubKey.(ed25519.PubKey)
+					rawpub := ed25519pub.Bytes()
+					result2, err := c.ABCIQuery(ctx, "/val", rawpub)
+					require.NoError(t, err)
+					qres := result2.Response
+					require.True(t, qres.IsOK())
+
+					var v abci.ValidatorUpdate
+					err = abci.ReadMessage(bytes.NewReader(qres.Value), &v)
+					require.NoError(t, err, "Error reading query result, value %v", qres.Value)
+
+					pk, err := encoding.PubKeyFromProto(v.PubKey)
+					require.NoError(t, err)
+
+					require.EqualValues(t, rawpub, pk, "Stored PubKey not equal with expected, value %v", string(qres.Value))
+					require.Equal(t, int64(9), v.Power, "Stored Power not equal with expected, value %v", string(qres.Value))
+
+					for _, fake := range fakes {
+						_, err := c.BroadcastEvidence(ctx, fake)
+						require.Error(t, err, "BroadcastEvidence(%s) succeeded, but the evidence was fake", fake)
+					}
+
+				})
+				t.Run("BroadcastEmpty", func(t *testing.T) {
+					_, err := c.BroadcastEvidence(ctx, nil)
+					assert.Error(t, err)
+				})
+			})
 		})
 	}
 }
diff --git a/rpc/test/helpers.go b/rpc/test/helpers.go
index 01aa83b4f3..e2f47839c2 100644
--- a/rpc/test/helpers.go
+++ b/rpc/test/helpers.go
@@ -73,6 +73,7 @@ func CreateConfig(testName string) *config.Config {
 	tm, rpc, grpc := makeAddrs()
 	c.P2P.ListenAddress = tm
 	c.RPC.ListenAddress = rpc
+	c.Consensus.WalPath = "rpc-test"
 	c.RPC.CORSAllowedOrigins = []string{"https://tendermint.com/"}
 	c.RPC.GRPCListenAddress = grpc
 	return c

From 36a1acff520b9f30925de9ad8f27189653709ea4 Mon Sep 17 00:00:00 2001
From: William Banfield <4561443+williambanfield@users.noreply.github.com>
Date: Wed, 13 Oct 2021 16:52:25 -0400
Subject: [PATCH 45/57] internal/proxy: add initial set of abci metrics (#7115)

This PR adds an initial set of metrics for use ABCI. The initial metrics enable the calculation of timing histograms and call counts for each of the ABCI methods. The metrics are also labeled as either 'sync' or 'async' to determine if the method call was performed using ABCI's `*Async` methods.

An example of these metrics is included here for reference:
```
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="0.0001"} 0
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="0.0004"} 5
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="0.002"} 12
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="0.009"} 13
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="0.02"} 13
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="0.1"} 13
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="0.65"} 13
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="2"} 13
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="6"} 13
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="25"} 13
tendermint_abci_connection_method_timing_bucket{chain_id="ci",method="commit",type="sync",le="+Inf"} 13
tendermint_abci_connection_method_timing_sum{chain_id="ci",method="commit",type="sync"} 0.007802058000000001
tendermint_abci_connection_method_timing_count{chain_id="ci",method="commit",type="sync"} 13
```

These metrics can easily be graphed using prometheus's `histogram_quantile(...)` method to pick out a particular quantile to graph or examine. I chose buckets that were somewhat of an estimate of expected range of times for ABCI operations. They start at .0001 seconds and range to 25 seconds. The hope is that this range captures enough possible times to be useful for us and operators.
---
 internal/blocksync/v0/reactor_test.go |  2 +-
 internal/consensus/metrics.go         |  9 +++++
 internal/consensus/replay_file.go     |  2 +-
 internal/consensus/replay_stubs.go    |  2 +-
 internal/consensus/replay_test.go     | 12 +++----
 internal/consensus/wal_generator.go   |  2 +-
 internal/proxy/app_conn.go            | 43 +++++++++++++++++++++---
 internal/proxy/metrics.go             | 47 +++++++++++++++++++++++++++
 internal/proxy/multi_app_conn.go      | 16 +++++----
 internal/proxy/multi_app_conn_test.go |  4 +--
 internal/state/execution_test.go      | 10 +++---
 internal/state/helpers_test.go        |  2 +-
 node/node.go                          |  9 +++--
 node/node_test.go                     |  6 ++--
 node/setup.go                         |  5 +--
 15 files changed, 134 insertions(+), 37 deletions(-)
 create mode 100644 internal/proxy/metrics.go

diff --git a/internal/blocksync/v0/reactor_test.go b/internal/blocksync/v0/reactor_test.go
index e947581aa8..312b1cb397 100644
--- a/internal/blocksync/v0/reactor_test.go
+++ b/internal/blocksync/v0/reactor_test.go
@@ -98,7 +98,7 @@ func (rts *reactorTestSuite) addNode(t *testing.T,
 	t.Helper()
 
 	rts.nodes = append(rts.nodes, nodeID)
-	rts.app[nodeID] = proxy.NewAppConns(abciclient.NewLocalCreator(&abci.BaseApplication{}))
+	rts.app[nodeID] = proxy.NewAppConns(abciclient.NewLocalCreator(&abci.BaseApplication{}), proxy.NopMetrics())
 	require.NoError(t, rts.app[nodeID].Start())
 
 	blockDB := dbm.NewMemDB()
diff --git a/internal/consensus/metrics.go b/internal/consensus/metrics.go
index bceac49425..a75f1505c7 100644
--- a/internal/consensus/metrics.go
+++ b/internal/consensus/metrics.go
@@ -61,6 +61,9 @@ type Metrics struct {
 
 	// Number of blockparts transmitted by peer.
 	BlockParts metrics.Counter
+
+	// Histogram of time taken per step annotated with reason that the step proceeded.
+	StepTime metrics.Histogram
 }
 
 // PrometheusMetrics returns Metrics build using Prometheus client library.
@@ -187,6 +190,12 @@ func PrometheusMetrics(namespace string, labelsAndValues ...string) *Metrics {
 			Name:      "block_parts",
 			Help:      "Number of blockparts transmitted by peer.",
 		}, append(labels, "peer_id")).With(labelsAndValues...),
+		StepTime: prometheus.NewHistogramFrom(stdprometheus.HistogramOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "step_time",
+			Help:      "Time spent per step.",
+		}, append(labels, "step", "reason")).With(labelsAndValues...),
 	}
 }
 
diff --git a/internal/consensus/replay_file.go b/internal/consensus/replay_file.go
index d009533bae..f60dff531c 100644
--- a/internal/consensus/replay_file.go
+++ b/internal/consensus/replay_file.go
@@ -312,7 +312,7 @@ func newConsensusStateForReplay(cfg config.BaseConfig, csConfig *config.Consensu
 
 	// Create proxyAppConn connection (consensus, mempool, query)
 	clientCreator, _ := proxy.DefaultClientCreator(cfg.ProxyApp, cfg.ABCI, cfg.DBDir())
-	proxyApp := proxy.NewAppConns(clientCreator)
+	proxyApp := proxy.NewAppConns(clientCreator, proxy.NopMetrics())
 	err = proxyApp.Start()
 	if err != nil {
 		tmos.Exit(fmt.Sprintf("Error starting proxy app conns: %v", err))
diff --git a/internal/consensus/replay_stubs.go b/internal/consensus/replay_stubs.go
index bc8c11cd92..1235baccbf 100644
--- a/internal/consensus/replay_stubs.go
+++ b/internal/consensus/replay_stubs.go
@@ -64,7 +64,7 @@ func newMockProxyApp(appHash []byte, abciResponses *tmstate.ABCIResponses) proxy
 	if err != nil {
 		panic(err)
 	}
-	return proxy.NewAppConnConsensus(cli)
+	return proxy.NewAppConnConsensus(cli, proxy.NopMetrics())
 }
 
 type mockProxyApp struct {
diff --git a/internal/consensus/replay_test.go b/internal/consensus/replay_test.go
index 97017985da..0d0ae36e81 100644
--- a/internal/consensus/replay_test.go
+++ b/internal/consensus/replay_test.go
@@ -745,7 +745,7 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod
 	if nBlocks > 0 {
 		// run nBlocks against a new client to build up the app state.
 		// use a throwaway tendermint state
-		proxyApp := proxy.NewAppConns(clientCreator2)
+		proxyApp := proxy.NewAppConns(clientCreator2, proxy.NopMetrics())
 		stateDB1 := dbm.NewMemDB()
 		stateStore := sm.NewStore(stateDB1)
 		err := stateStore.Save(genesisState)
@@ -765,7 +765,7 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod
 	// now start the app using the handshake - it should sync
 	genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile())
 	handshaker := NewHandshaker(stateStore, state, store, genDoc)
-	proxyApp := proxy.NewAppConns(clientCreator2)
+	proxyApp := proxy.NewAppConns(clientCreator2, proxy.NopMetrics())
 	if err := proxyApp.Start(); err != nil {
 		t.Fatalf("Error starting proxy app connections: %v", err)
 	}
@@ -893,7 +893,7 @@ func buildTMStateFromChain(
 	defer kvstoreApp.Close()
 	clientCreator := abciclient.NewLocalCreator(kvstoreApp)
 
-	proxyApp := proxy.NewAppConns(clientCreator)
+	proxyApp := proxy.NewAppConns(clientCreator, proxy.NopMetrics())
 	if err := proxyApp.Start(); err != nil {
 		panic(err)
 	}
@@ -960,7 +960,7 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	{
 		app := &badApp{numBlocks: 3, allHashesAreWrong: true}
 		clientCreator := abciclient.NewLocalCreator(app)
-		proxyApp := proxy.NewAppConns(clientCreator)
+		proxyApp := proxy.NewAppConns(clientCreator, proxy.NopMetrics())
 		err := proxyApp.Start()
 		require.NoError(t, err)
 		t.Cleanup(func() {
@@ -984,7 +984,7 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	{
 		app := &badApp{numBlocks: 3, onlyLastHashIsWrong: true}
 		clientCreator := abciclient.NewLocalCreator(app)
-		proxyApp := proxy.NewAppConns(clientCreator)
+		proxyApp := proxy.NewAppConns(clientCreator, proxy.NopMetrics())
 		err := proxyApp.Start()
 		require.NoError(t, err)
 		t.Cleanup(func() {
@@ -1243,7 +1243,7 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	// now start the app using the handshake - it should sync
 	genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile())
 	handshaker := NewHandshaker(stateStore, state, store, genDoc)
-	proxyApp := proxy.NewAppConns(clientCreator)
+	proxyApp := proxy.NewAppConns(clientCreator, proxy.NopMetrics())
 	if err := proxyApp.Start(); err != nil {
 		t.Fatalf("Error starting proxy app connections: %v", err)
 	}
diff --git a/internal/consensus/wal_generator.go b/internal/consensus/wal_generator.go
index 7e31188fa7..4b43754989 100644
--- a/internal/consensus/wal_generator.go
+++ b/internal/consensus/wal_generator.go
@@ -65,7 +65,7 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) {
 
 	blockStore := store.NewBlockStore(blockStoreDB)
 
-	proxyApp := proxy.NewAppConns(abciclient.NewLocalCreator(app))
+	proxyApp := proxy.NewAppConns(abciclient.NewLocalCreator(app), proxy.NopMetrics())
 	proxyApp.SetLogger(logger.With("module", "proxy"))
 	if err := proxyApp.Start(); err != nil {
 		return fmt.Errorf("failed to start proxy app connections: %w", err)
diff --git a/internal/proxy/app_conn.go b/internal/proxy/app_conn.go
index ca2c7c1096..803875646b 100644
--- a/internal/proxy/app_conn.go
+++ b/internal/proxy/app_conn.go
@@ -2,7 +2,9 @@ package proxy
 
 import (
 	"context"
+	"time"
 
+	"github.com/go-kit/kit/metrics"
 	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/types"
 )
@@ -56,11 +58,13 @@ type AppConnSnapshot interface {
 // Implements AppConnConsensus (subset of abciclient.Client)
 
 type appConnConsensus struct {
+	metrics *Metrics
 	appConn abciclient.Client
 }
 
-func NewAppConnConsensus(appConn abciclient.Client) AppConnConsensus {
+func NewAppConnConsensus(appConn abciclient.Client, metrics *Metrics) AppConnConsensus {
 	return &appConnConsensus{
+		metrics: metrics,
 		appConn: appConn,
 	}
 }
@@ -77,6 +81,7 @@ func (app *appConnConsensus) InitChainSync(
 	ctx context.Context,
 	req types.RequestInitChain,
 ) (*types.ResponseInitChain, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "init_chain", "type", "sync"))()
 	return app.appConn.InitChainSync(ctx, req)
 }
 
@@ -84,6 +89,7 @@ func (app *appConnConsensus) BeginBlockSync(
 	ctx context.Context,
 	req types.RequestBeginBlock,
 ) (*types.ResponseBeginBlock, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "begin_block", "type", "sync"))()
 	return app.appConn.BeginBlockSync(ctx, req)
 }
 
@@ -91,6 +97,7 @@ func (app *appConnConsensus) DeliverTxAsync(
 	ctx context.Context,
 	req types.RequestDeliverTx,
 ) (*abciclient.ReqRes, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "deliver_tx", "type", "async"))()
 	return app.appConn.DeliverTxAsync(ctx, req)
 }
 
@@ -98,10 +105,12 @@ func (app *appConnConsensus) EndBlockSync(
 	ctx context.Context,
 	req types.RequestEndBlock,
 ) (*types.ResponseEndBlock, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "deliver_tx", "type", "sync"))()
 	return app.appConn.EndBlockSync(ctx, req)
 }
 
 func (app *appConnConsensus) CommitSync(ctx context.Context) (*types.ResponseCommit, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "commit", "type", "sync"))()
 	return app.appConn.CommitSync(ctx)
 }
 
@@ -109,11 +118,13 @@ func (app *appConnConsensus) CommitSync(ctx context.Context) (*types.ResponseCom
 // Implements AppConnMempool (subset of abciclient.Client)
 
 type appConnMempool struct {
+	metrics *Metrics
 	appConn abciclient.Client
 }
 
-func NewAppConnMempool(appConn abciclient.Client) AppConnMempool {
+func NewAppConnMempool(appConn abciclient.Client, metrics *Metrics) AppConnMempool {
 	return &appConnMempool{
+		metrics: metrics,
 		appConn: appConn,
 	}
 }
@@ -127,18 +138,22 @@ func (app *appConnMempool) Error() error {
 }
 
 func (app *appConnMempool) FlushAsync(ctx context.Context) (*abciclient.ReqRes, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "flush", "type", "async"))()
 	return app.appConn.FlushAsync(ctx)
 }
 
 func (app *appConnMempool) FlushSync(ctx context.Context) error {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "flush", "type", "sync"))()
 	return app.appConn.FlushSync(ctx)
 }
 
 func (app *appConnMempool) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*abciclient.ReqRes, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "check_tx", "type", "async"))()
 	return app.appConn.CheckTxAsync(ctx, req)
 }
 
 func (app *appConnMempool) CheckTxSync(ctx context.Context, req types.RequestCheckTx) (*types.ResponseCheckTx, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "check_tx", "type", "sync"))()
 	return app.appConn.CheckTxSync(ctx, req)
 }
 
@@ -146,11 +161,13 @@ func (app *appConnMempool) CheckTxSync(ctx context.Context, req types.RequestChe
 // Implements AppConnQuery (subset of abciclient.Client)
 
 type appConnQuery struct {
+	metrics *Metrics
 	appConn abciclient.Client
 }
 
-func NewAppConnQuery(appConn abciclient.Client) AppConnQuery {
+func NewAppConnQuery(appConn abciclient.Client, metrics *Metrics) AppConnQuery {
 	return &appConnQuery{
+		metrics: metrics,
 		appConn: appConn,
 	}
 }
@@ -160,14 +177,17 @@ func (app *appConnQuery) Error() error {
 }
 
 func (app *appConnQuery) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "echo", "type", "sync"))()
 	return app.appConn.EchoSync(ctx, msg)
 }
 
 func (app *appConnQuery) InfoSync(ctx context.Context, req types.RequestInfo) (*types.ResponseInfo, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "info", "type", "sync"))()
 	return app.appConn.InfoSync(ctx, req)
 }
 
 func (app *appConnQuery) QuerySync(ctx context.Context, reqQuery types.RequestQuery) (*types.ResponseQuery, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "query", "type", "sync"))()
 	return app.appConn.QuerySync(ctx, reqQuery)
 }
 
@@ -175,11 +195,13 @@ func (app *appConnQuery) QuerySync(ctx context.Context, reqQuery types.RequestQu
 // Implements AppConnSnapshot (subset of abciclient.Client)
 
 type appConnSnapshot struct {
+	metrics *Metrics
 	appConn abciclient.Client
 }
 
-func NewAppConnSnapshot(appConn abciclient.Client) AppConnSnapshot {
+func NewAppConnSnapshot(appConn abciclient.Client, metrics *Metrics) AppConnSnapshot {
 	return &appConnSnapshot{
+		metrics: metrics,
 		appConn: appConn,
 	}
 }
@@ -192,6 +214,7 @@ func (app *appConnSnapshot) ListSnapshotsSync(
 	ctx context.Context,
 	req types.RequestListSnapshots,
 ) (*types.ResponseListSnapshots, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "list_snapshots", "type", "sync"))()
 	return app.appConn.ListSnapshotsSync(ctx, req)
 }
 
@@ -199,17 +222,29 @@ func (app *appConnSnapshot) OfferSnapshotSync(
 	ctx context.Context,
 	req types.RequestOfferSnapshot,
 ) (*types.ResponseOfferSnapshot, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "offer_snapshot", "type", "sync"))()
 	return app.appConn.OfferSnapshotSync(ctx, req)
 }
 
 func (app *appConnSnapshot) LoadSnapshotChunkSync(
 	ctx context.Context,
 	req types.RequestLoadSnapshotChunk) (*types.ResponseLoadSnapshotChunk, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "load_snapshot_chunk", "type", "sync"))()
 	return app.appConn.LoadSnapshotChunkSync(ctx, req)
 }
 
 func (app *appConnSnapshot) ApplySnapshotChunkSync(
 	ctx context.Context,
 	req types.RequestApplySnapshotChunk) (*types.ResponseApplySnapshotChunk, error) {
+	defer addTimeSample(app.metrics.MethodTiming.With("method", "apply_snapshot_chunk", "type", "sync"))()
 	return app.appConn.ApplySnapshotChunkSync(ctx, req)
 }
+
+// addTimeSample returns a function that, when called, adds an observation to m.
+// The observation added to m is the number of seconds ellapsed since addTimeSample
+// was initially called. addTimeSample is meant to be called in a defer to calculate
+// the amount of time a function takes to complete.
+func addTimeSample(m metrics.Histogram) func() {
+	start := time.Now()
+	return func() { m.Observe(time.Since(start).Seconds()) }
+}
diff --git a/internal/proxy/metrics.go b/internal/proxy/metrics.go
new file mode 100644
index 0000000000..99bd7d7b04
--- /dev/null
+++ b/internal/proxy/metrics.go
@@ -0,0 +1,47 @@
+package proxy
+
+import (
+	"github.com/go-kit/kit/metrics"
+	"github.com/go-kit/kit/metrics/discard"
+	"github.com/go-kit/kit/metrics/prometheus"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+)
+
+const (
+	// MetricsSubsystem is a subsystem shared by all metrics exposed by this
+	// package.
+	MetricsSubsystem = "abci_connection"
+)
+
+// Metrics contains the prometheus metrics exposed by the proxy package.
+type Metrics struct {
+	MethodTiming metrics.Histogram
+}
+
+// PrometheusMetrics constructs a Metrics instance that collects metrics samples.
+// The resulting metrics will be prefixed with namespace and labeled with the
+// defaultLabelsAndValues. defaultLabelsAndValues must be a list of string pairs
+// where the first of each pair is the label and the second is the value.
+func PrometheusMetrics(namespace string, defaultLabelsAndValues ...string) *Metrics {
+	defaultLabels := []string{}
+	for i := 0; i < len(defaultLabelsAndValues); i += 2 {
+		defaultLabels = append(defaultLabels, defaultLabelsAndValues[i])
+	}
+	return &Metrics{
+		MethodTiming: prometheus.NewHistogramFrom(stdprometheus.HistogramOpts{
+			Namespace: namespace,
+			Subsystem: MetricsSubsystem,
+			Name:      "method_timing",
+			Help:      "ABCI Method Timing",
+			Buckets:   []float64{.0001, .0004, .002, .009, .02, .1, .65, 2, 6, 25},
+		}, append(defaultLabels, []string{"method", "type"}...)).With(defaultLabelsAndValues...),
+	}
+}
+
+// NopMetrics constructs a Metrics instance that discards all samples and is suitable
+// for testing.
+func NopMetrics() *Metrics {
+	return &Metrics{
+		MethodTiming: discard.NewHistogram(),
+	}
+}
diff --git a/internal/proxy/multi_app_conn.go b/internal/proxy/multi_app_conn.go
index df49df2873..0bcc64af67 100644
--- a/internal/proxy/multi_app_conn.go
+++ b/internal/proxy/multi_app_conn.go
@@ -33,8 +33,8 @@ type AppConns interface {
 }
 
 // NewAppConns calls NewMultiAppConn.
-func NewAppConns(clientCreator abciclient.Creator) AppConns {
-	return NewMultiAppConn(clientCreator)
+func NewAppConns(clientCreator abciclient.Creator, metrics *Metrics) AppConns {
+	return NewMultiAppConn(clientCreator, metrics)
 }
 
 // multiAppConn implements AppConns.
@@ -45,6 +45,7 @@ func NewAppConns(clientCreator abciclient.Creator) AppConns {
 type multiAppConn struct {
 	service.BaseService
 
+	metrics       *Metrics
 	consensusConn AppConnConsensus
 	mempoolConn   AppConnMempool
 	queryConn     AppConnQuery
@@ -59,8 +60,9 @@ type multiAppConn struct {
 }
 
 // NewMultiAppConn makes all necessary abci connections to the application.
-func NewMultiAppConn(clientCreator abciclient.Creator) AppConns {
+func NewMultiAppConn(clientCreator abciclient.Creator, metrics *Metrics) AppConns {
 	multiAppConn := &multiAppConn{
+		metrics:       metrics,
 		clientCreator: clientCreator,
 	}
 	multiAppConn.BaseService = *service.NewBaseService(nil, "multiAppConn", multiAppConn)
@@ -89,7 +91,7 @@ func (app *multiAppConn) OnStart() error {
 		return err
 	}
 	app.queryConnClient = c
-	app.queryConn = NewAppConnQuery(c)
+	app.queryConn = NewAppConnQuery(c, app.metrics)
 
 	c, err = app.abciClientFor(connSnapshot)
 	if err != nil {
@@ -97,7 +99,7 @@ func (app *multiAppConn) OnStart() error {
 		return err
 	}
 	app.snapshotConnClient = c
-	app.snapshotConn = NewAppConnSnapshot(c)
+	app.snapshotConn = NewAppConnSnapshot(c, app.metrics)
 
 	c, err = app.abciClientFor(connMempool)
 	if err != nil {
@@ -105,7 +107,7 @@ func (app *multiAppConn) OnStart() error {
 		return err
 	}
 	app.mempoolConnClient = c
-	app.mempoolConn = NewAppConnMempool(c)
+	app.mempoolConn = NewAppConnMempool(c, app.metrics)
 
 	c, err = app.abciClientFor(connConsensus)
 	if err != nil {
@@ -113,7 +115,7 @@ func (app *multiAppConn) OnStart() error {
 		return err
 	}
 	app.consensusConnClient = c
-	app.consensusConn = NewAppConnConsensus(c)
+	app.consensusConn = NewAppConnConsensus(c, app.metrics)
 
 	// Kill Tendermint if the ABCI application crashes.
 	go app.killTMOnClientError()
diff --git a/internal/proxy/multi_app_conn_test.go b/internal/proxy/multi_app_conn_test.go
index 55bcc7524f..25ed692aba 100644
--- a/internal/proxy/multi_app_conn_test.go
+++ b/internal/proxy/multi_app_conn_test.go
@@ -31,7 +31,7 @@ func TestAppConns_Start_Stop(t *testing.T) {
 		return clientMock, nil
 	}
 
-	appConns := NewAppConns(creator)
+	appConns := NewAppConns(creator, NopMetrics())
 
 	err := appConns.Start()
 	require.NoError(t, err)
@@ -72,7 +72,7 @@ func TestAppConns_Failure(t *testing.T) {
 		return clientMock, nil
 	}
 
-	appConns := NewAppConns(creator)
+	appConns := NewAppConns(creator, NopMetrics())
 
 	err := appConns.Start()
 	require.NoError(t, err)
diff --git a/internal/state/execution_test.go b/internal/state/execution_test.go
index 8eff0430d3..a66b677f94 100644
--- a/internal/state/execution_test.go
+++ b/internal/state/execution_test.go
@@ -36,7 +36,7 @@ var (
 func TestApplyBlock(t *testing.T) {
 	app := &testApp{}
 	cc := abciclient.NewLocalCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
@@ -61,7 +61,7 @@ func TestApplyBlock(t *testing.T) {
 func TestBeginBlockValidators(t *testing.T) {
 	app := &testApp{}
 	cc := abciclient.NewLocalCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // no need to check error again
@@ -124,7 +124,7 @@ func TestBeginBlockValidators(t *testing.T) {
 func TestBeginBlockByzantineValidators(t *testing.T) {
 	app := &testApp{}
 	cc := abciclient.NewLocalCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
@@ -349,7 +349,7 @@ func TestUpdateValidators(t *testing.T) {
 func TestEndBlockValidatorUpdates(t *testing.T) {
 	app := &testApp{}
 	cc := abciclient.NewLocalCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
@@ -422,7 +422,7 @@ func TestEndBlockValidatorUpdates(t *testing.T) {
 func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) {
 	app := &testApp{}
 	cc := abciclient.NewLocalCreator(app)
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
diff --git a/internal/state/helpers_test.go b/internal/state/helpers_test.go
index f8ed77b320..0cedebb008 100644
--- a/internal/state/helpers_test.go
+++ b/internal/state/helpers_test.go
@@ -31,7 +31,7 @@ type paramsChangeTestCase struct {
 func newTestApp() proxy.AppConns {
 	app := &testApp{}
 	cc := abciclient.NewLocalCreator(app)
-	return proxy.NewAppConns(cc)
+	return proxy.NewAppConns(cc, proxy.NopMetrics())
 }
 
 func makeAndCommitGoodBlock(
diff --git a/node/node.go b/node/node.go
index 6ee0d30f98..e15bde5537 100644
--- a/node/node.go
+++ b/node/node.go
@@ -157,8 +157,10 @@ func makeNode(cfg *config.Config,
 
 	}
 
+	nodeMetrics := defaultMetricsProvider(cfg.Instrumentation)(genDoc.ChainID)
+
 	// Create the proxyApp and establish connections to the ABCI app (consensus, mempool, query).
-	proxyApp, err := createAndStartProxyAppConns(clientCreator, logger)
+	proxyApp, err := createAndStartProxyAppConns(clientCreator, logger, nodeMetrics.proxy)
 	if err != nil {
 		return nil, combineCloseError(err, makeCloser(closers))
 
@@ -268,8 +270,6 @@ func makeNode(cfg *config.Config,
 			makeCloser(closers))
 	}
 
-	nodeMetrics := defaultMetricsProvider(cfg.Instrumentation)(genDoc.ChainID)
-
 	router, err := createRouter(p2pLogger, nodeMetrics.p2p, nodeInfo, nodeKey.PrivKey,
 		peerManager, transport, getRouterConfig(cfg, proxyApp))
 	if err != nil {
@@ -988,6 +988,7 @@ type nodeMetrics struct {
 	mempool   *mempool.Metrics
 	state     *sm.Metrics
 	statesync *statesync.Metrics
+	proxy     *proxy.Metrics
 }
 
 // metricsProvider returns consensus, p2p, mempool, state, statesync Metrics.
@@ -1004,6 +1005,7 @@ func defaultMetricsProvider(cfg *config.InstrumentationConfig) metricsProvider {
 				mempool.PrometheusMetrics(cfg.Namespace, "chain_id", chainID),
 				sm.PrometheusMetrics(cfg.Namespace, "chain_id", chainID),
 				statesync.PrometheusMetrics(cfg.Namespace, "chain_id", chainID),
+				proxy.PrometheusMetrics(cfg.Namespace, "chain_id", chainID),
 			}
 		}
 		return &nodeMetrics{
@@ -1012,6 +1014,7 @@ func defaultMetricsProvider(cfg *config.InstrumentationConfig) metricsProvider {
 			mempool.NopMetrics(),
 			sm.NopMetrics(),
 			statesync.NopMetrics(),
+			proxy.NopMetrics(),
 		}
 	}
 }
diff --git a/node/node_test.go b/node/node_test.go
index 7039b09e18..19f27a6407 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -240,7 +240,7 @@ func TestCreateProposalBlock(t *testing.T) {
 	cfg := config.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(cfg.RootDir)
 	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
@@ -335,7 +335,7 @@ func TestMaxTxsProposalBlockSize(t *testing.T) {
 	cfg := config.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(cfg.RootDir)
 	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
@@ -400,7 +400,7 @@ func TestMaxProposalBlockSize(t *testing.T) {
 	cfg := config.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(cfg.RootDir)
 	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
-	proxyApp := proxy.NewAppConns(cc)
+	proxyApp := proxy.NewAppConns(cc, proxy.NopMetrics())
 	err := proxyApp.Start()
 	require.Nil(t, err)
 	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
diff --git a/node/setup.go b/node/setup.go
index ac36b08582..ebaa576c2f 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -90,8 +90,9 @@ func initDBs(
 	return blockStore, stateDB, makeCloser(closers), nil
 }
 
-func createAndStartProxyAppConns(clientCreator abciclient.Creator, logger log.Logger) (proxy.AppConns, error) {
-	proxyApp := proxy.NewAppConns(clientCreator)
+// nolint:lll
+func createAndStartProxyAppConns(clientCreator abciclient.Creator, logger log.Logger, metrics *proxy.Metrics) (proxy.AppConns, error) {
+	proxyApp := proxy.NewAppConns(clientCreator, metrics)
 	proxyApp.SetLogger(logger.With("module", "proxy"))
 	if err := proxyApp.Start(); err != nil {
 		return nil, fmt.Errorf("error starting proxy app connections: %v", err)

From ff7b0e638eca88077a6eacbd33974abd8a6d92c9 Mon Sep 17 00:00:00 2001
From: William Banfield <4561443+williambanfield@users.noreply.github.com>
Date: Wed, 13 Oct 2021 17:18:44 -0400
Subject: [PATCH 46/57] p2p: fix priority queue bytes pending calculation
 (#7120)

This metric describes itself as 'pending' but never actual decrements when the messages are removed from the queue.

This change fixes that by decrementing the metric when the data is removed from the queue.
---
 internal/p2p/pqueue.go | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/internal/p2p/pqueue.go b/internal/p2p/pqueue.go
index e4560c7bd4..b19436e15a 100644
--- a/internal/p2p/pqueue.go
+++ b/internal/p2p/pqueue.go
@@ -167,13 +167,12 @@ func (s *pqScheduler) process() {
 				timestamp: time.Now().UTC(),
 			}
 
-			s.metrics.PeerPendingSendBytes.With("peer_id", string(pqEnv.envelope.To)).Add(float64(pqEnv.size))
-
 			// enqueue
 
 			// Check if we have sufficient capacity to simply enqueue the incoming
 			// Envelope.
 			if s.size+pqEnv.size <= s.capacity {
+				s.metrics.PeerPendingSendBytes.With("peer_id", string(pqEnv.envelope.To)).Add(float64(pqEnv.size))
 				// enqueue the incoming Envelope
 				s.push(pqEnv)
 			} else {
@@ -213,6 +212,8 @@ func (s *pqScheduler) process() {
 									"capacity", s.capacity,
 								)
 
+								s.metrics.PeerPendingSendBytes.With("peer_id", string(pqEnvTmp.envelope.To)).Add(float64(-pqEnvTmp.size))
+
 								// dequeue/drop from the priority queue
 								heap.Remove(s.pq, pqEnvTmp.index)
 
@@ -257,6 +258,8 @@ func (s *pqScheduler) process() {
 				s.metrics.PeerSendBytesTotal.With(
 					"chID", chIDStr,
 					"peer_id", string(pqEnv.envelope.To)).Add(float64(pqEnv.size))
+				s.metrics.PeerPendingSendBytes.With(
+					"peer_id", string(pqEnv.envelope.To)).Add(float64(-pqEnv.size))
 				select {
 				case s.dequeueCh <- pqEnv.envelope:
 				case <-s.closer.Done():

From 86f00135dd5d14a382a033c705062839d75e66cf Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Wed, 13 Oct 2021 15:01:01 -0700
Subject: [PATCH 47/57] rpc: Remove the deprecated gRPC interface to the RPC
 service (#7121)

This change removes the partial gRPC interface to the RPC service, which was
deprecated in resolution of #6718.

Details:
- rpc: Remove the client and server interfaces and proto definitions.
- Remove the gRPC settings from the config library.
- Remove gRPC setup for the RPC service in the node startup.
- Fix various test helpers to remove gRPC bits.
- Remove the --rpc.grpc-laddr flag from the CLI.

Note that to satisfy the protobuf interface check, this change also includes a
temporary edit to buf.yaml, that I will revert after this is merged.
---
 CHANGELOG_PENDING.md                  |   2 +
 Makefile                              |   6 +-
 buf.yaml                              |   3 +
 cmd/tendermint/commands/run_node.go   |   4 -
 config/config.go                      |  30 +-
 config/config_test.go                 |   1 -
 config/toml.go                        |  20 +-
 internal/consensus/wal_generator.go   |  18 +-
 node/node.go                          |  29 -
 proto/tendermint/rpc/grpc/types.proto |  32 -
 rpc/grpc/api.go                       |  41 --
 rpc/grpc/client_server.go             |  40 --
 rpc/grpc/grpc_test.go                 |  45 --
 rpc/grpc/types.pb.go                  | 924 --------------------------
 rpc/test/helpers.go                   |  36 +-
 test/app/grpc_client.go               |  42 --
 16 files changed, 33 insertions(+), 1240 deletions(-)
 delete mode 100644 proto/tendermint/rpc/grpc/types.proto
 delete mode 100644 rpc/grpc/api.go
 delete mode 100644 rpc/grpc/client_server.go
 delete mode 100644 rpc/grpc/grpc_test.go
 delete mode 100644 rpc/grpc/types.pb.go
 delete mode 100644 test/app/grpc_client.go

diff --git a/CHANGELOG_PENDING.md b/CHANGELOG_PENDING.md
index 0f8ba5ea7c..9d8148783c 100644
--- a/CHANGELOG_PENDING.md
+++ b/CHANGELOG_PENDING.md
@@ -12,6 +12,8 @@ Special thanks to external contributors on this release:
 
 - CLI/RPC/Config
 
+  - [rpc] Remove the deprecated gRPC interface to the RPC service (@creachadair).
+
 - Apps
 
 - P2P Protocol
diff --git a/Makefile b/Makefile
index 7f5dc677cb..2bac7f5bfa 100644
--- a/Makefile
+++ b/Makefile
@@ -89,7 +89,7 @@ proto-gen:
 .PHONY: proto-gen
 
 proto-lint:
-	@$(DOCKER_BUF) check lint --error-format=json
+	@$(DOCKER_BUF) lint --error-format=json
 .PHONY: proto-lint
 
 proto-format:
@@ -98,11 +98,11 @@ proto-format:
 .PHONY: proto-format
 
 proto-check-breaking:
-	@$(DOCKER_BUF) check breaking --against-input .git#branch=master
+	@$(DOCKER_BUF) breaking --against .git#branch=master
 .PHONY: proto-check-breaking
 
 proto-check-breaking-ci:
-	@$(DOCKER_BUF) check breaking --against-input $(HTTPS_GIT)#branch=master
+	@$(DOCKER_BUF) breaking --against $(HTTPS_GIT)#branch=master
 .PHONY: proto-check-breaking-ci
 
 ###############################################################################
diff --git a/buf.yaml b/buf.yaml
index cc4aced576..98feb708e2 100644
--- a/buf.yaml
+++ b/buf.yaml
@@ -14,3 +14,6 @@ lint:
 breaking:
   use:
     - FILE
+  ignore:
+    # TODO(#7075): Remove after file deletion is merged.
+    - tendermint/rpc
diff --git a/cmd/tendermint/commands/run_node.go b/cmd/tendermint/commands/run_node.go
index 0c6d3271ec..a5fa72ed57 100644
--- a/cmd/tendermint/commands/run_node.go
+++ b/cmd/tendermint/commands/run_node.go
@@ -70,10 +70,6 @@ func AddNodeFlags(cmd *cobra.Command) {
 
 	// rpc flags
 	cmd.Flags().String("rpc.laddr", config.RPC.ListenAddress, "RPC listen address. Port required")
-	cmd.Flags().String(
-		"rpc.grpc-laddr",
-		config.RPC.GRPCListenAddress,
-		"GRPC listen address (BroadcastTx only). 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)")
 
diff --git a/config/config.go b/config/config.go
index 0e204b6e68..a9b2576fd5 100644
--- a/config/config.go
+++ b/config/config.go
@@ -455,24 +455,10 @@ type RPCConfig struct {
 	// A list of non simple headers the client is allowed to use with cross-domain requests.
 	CORSAllowedHeaders []string `mapstructure:"cors-allowed-headers"`
 
-	// TCP or UNIX socket address for the gRPC server to listen on
-	// NOTE: This server only supports /broadcast_tx_commit
-	// Deprecated: gRPC in the RPC layer of Tendermint will be removed in 0.36.
-	GRPCListenAddress string `mapstructure:"grpc-laddr"`
-
-	// Maximum number of simultaneous connections.
-	// Does not include RPC (HTTP&WebSocket) connections. See max-open-connections
-	// If you want to accept a larger number than the default, make sure
-	// you increase your OS limits.
-	// 0 - unlimited.
-	// Deprecated: gRPC in the RPC layer of Tendermint will be removed in 0.36.
-	GRPCMaxOpenConnections int `mapstructure:"grpc-max-open-connections"`
-
 	// Activate unsafe RPC commands like /dial-persistent-peers and /unsafe-flush-mempool
 	Unsafe bool `mapstructure:"unsafe"`
 
 	// Maximum number of simultaneous connections (including WebSocket).
-	// Does not include gRPC connections. See grpc-max-open-connections
 	// If you want to accept a larger number than the default, make sure
 	// you increase your OS limits.
 	// 0 - unlimited.
@@ -486,7 +472,7 @@ type RPCConfig struct {
 	MaxSubscriptionClients int `mapstructure:"max-subscription-clients"`
 
 	// Maximum number of unique queries a given client can /subscribe to
-	// If you're using GRPC (or Local RPC client) and /broadcast_tx_commit, set
+	// If you're using a Local RPC client and /broadcast_tx_commit, set this
 	// to the estimated maximum number of broadcast_tx_commit calls per block.
 	MaxSubscriptionsPerClient int `mapstructure:"max-subscriptions-per-client"`
 
@@ -527,12 +513,10 @@ type RPCConfig struct {
 // DefaultRPCConfig returns a default configuration for the RPC server
 func DefaultRPCConfig() *RPCConfig {
 	return &RPCConfig{
-		ListenAddress:          "tcp://127.0.0.1:26657",
-		CORSAllowedOrigins:     []string{},
-		CORSAllowedMethods:     []string{http.MethodHead, http.MethodGet, http.MethodPost},
-		CORSAllowedHeaders:     []string{"Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time"},
-		GRPCListenAddress:      "",
-		GRPCMaxOpenConnections: 900,
+		ListenAddress:      "tcp://127.0.0.1:26657",
+		CORSAllowedOrigins: []string{},
+		CORSAllowedMethods: []string{http.MethodHead, http.MethodGet, http.MethodPost},
+		CORSAllowedHeaders: []string{"Origin", "Accept", "Content-Type", "X-Requested-With", "X-Server-Time"},
 
 		Unsafe:             false,
 		MaxOpenConnections: 900,
@@ -553,7 +537,6 @@ func DefaultRPCConfig() *RPCConfig {
 func TestRPCConfig() *RPCConfig {
 	cfg := DefaultRPCConfig()
 	cfg.ListenAddress = "tcp://127.0.0.1:36657"
-	cfg.GRPCListenAddress = "tcp://127.0.0.1:36658"
 	cfg.Unsafe = true
 	return cfg
 }
@@ -561,9 +544,6 @@ func TestRPCConfig() *RPCConfig {
 // ValidateBasic performs basic validation (checking param bounds, etc.) and
 // returns an error if any check fails.
 func (cfg *RPCConfig) ValidateBasic() error {
-	if cfg.GRPCMaxOpenConnections < 0 {
-		return errors.New("grpc-max-open-connections can't be negative")
-	}
 	if cfg.MaxOpenConnections < 0 {
 		return errors.New("max-open-connections can't be negative")
 	}
diff --git a/config/config_test.go b/config/config_test.go
index db0fb59673..1813144924 100644
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -66,7 +66,6 @@ func TestRPCConfigValidateBasic(t *testing.T) {
 	assert.NoError(t, cfg.ValidateBasic())
 
 	fieldsToTest := []string{
-		"GRPCMaxOpenConnections",
 		"MaxOpenConnections",
 		"MaxSubscriptionClients",
 		"MaxSubscriptionsPerClient",
diff --git a/config/toml.go b/config/toml.go
index 1159640fb1..3be385060c 100644
--- a/config/toml.go
+++ b/config/toml.go
@@ -193,26 +193,10 @@ cors-allowed-methods = [{{ range .RPC.CORSAllowedMethods }}{{ printf "%q, " . }}
 # A list of non simple headers the client is allowed to use with cross-domain requests
 cors-allowed-headers = [{{ range .RPC.CORSAllowedHeaders }}{{ printf "%q, " . }}{{end}}]
 
-# TCP or UNIX socket address for the gRPC server to listen on
-# NOTE: This server only supports /broadcast_tx_commit
-# Deprecated gRPC  in the RPC layer of Tendermint will be deprecated in 0.36.
-grpc-laddr = "{{ .RPC.GRPCListenAddress }}"
-
-# Maximum number of simultaneous connections.
-# Does not include RPC (HTTP&WebSocket) connections. See max-open-connections
-# If you want to accept a larger number than the default, make sure
-# you increase your OS limits.
-# 0 - unlimited.
-# Should be < {ulimit -Sn} - {MaxNumInboundPeers} - {MaxNumOutboundPeers} - {N of wal, db and other open files}
-# 1024 - 40 - 10 - 50 = 924 = ~900
-# Deprecated gRPC  in the RPC layer of Tendermint will be deprecated in 0.36.
-grpc-max-open-connections = {{ .RPC.GRPCMaxOpenConnections }}
-
 # Activate unsafe RPC commands like /dial-seeds and /unsafe-flush-mempool
 unsafe = {{ .RPC.Unsafe }}
 
 # Maximum number of simultaneous connections (including WebSocket).
-# Does not include gRPC connections. See grpc-max-open-connections
 # If you want to accept a larger number than the default, make sure
 # you increase your OS limits.
 # 0 - unlimited.
@@ -226,8 +210,8 @@ max-open-connections = {{ .RPC.MaxOpenConnections }}
 max-subscription-clients = {{ .RPC.MaxSubscriptionClients }}
 
 # Maximum number of unique queries a given client can /subscribe to
-# If you're using GRPC (or Local RPC client) and /broadcast_tx_commit, set to
-# the estimated # maximum number of broadcast_tx_commit calls per block.
+# If you're using a Local RPC client and /broadcast_tx_commit, set this
+# to the estimated maximum number of broadcast_tx_commit calls per block.
 max-subscriptions-per-client = {{ .RPC.MaxSubscriptionsPerClient }}
 
 # How long to wait for a tx to be committed during /broadcast_tx_commit.
diff --git a/internal/consensus/wal_generator.go b/internal/consensus/wal_generator.go
index 4b43754989..f81234f977 100644
--- a/internal/consensus/wal_generator.go
+++ b/internal/consensus/wal_generator.go
@@ -145,22 +145,22 @@ func randPort() int {
 	return base + mrand.Intn(spread)
 }
 
-func makeAddrs() (string, string, string) {
+// makeAddrs constructs local TCP addresses for node services.
+// It uses consecutive ports from a random starting point, so that concurrent
+// instances are less likely to collide.
+func makeAddrs() (p2pAddr, rpcAddr string) {
+	const addrTemplate = "tcp://127.0.0.1:%d"
 	start := randPort()
-	return fmt.Sprintf("tcp://127.0.0.1:%d", start),
-		fmt.Sprintf("tcp://127.0.0.1:%d", start+1),
-		fmt.Sprintf("tcp://127.0.0.1:%d", start+2)
+	return fmt.Sprintf(addrTemplate, start), fmt.Sprintf(addrTemplate, start+1)
 }
 
 // getConfig returns a config for test cases
 func getConfig(t *testing.T) *config.Config {
 	c := config.ResetTestRoot(t.Name())
 
-	// and we use random ports to run in parallel
-	tm, rpc, grpc := makeAddrs()
-	c.P2P.ListenAddress = tm
-	c.RPC.ListenAddress = rpc
-	c.RPC.GRPCListenAddress = grpc
+	p2pAddr, rpcAddr := makeAddrs()
+	c.P2P.ListenAddress = p2pAddr
+	c.RPC.ListenAddress = rpcAddr
 	return c
 }
 
diff --git a/node/node.go b/node/node.go
index e15bde5537..b6c47a9ce8 100644
--- a/node/node.go
+++ b/node/node.go
@@ -34,7 +34,6 @@ import (
 	tmtime "github.com/tendermint/tendermint/libs/time"
 	"github.com/tendermint/tendermint/privval"
 	tmgrpc "github.com/tendermint/tendermint/privval/grpc"
-	grpccore "github.com/tendermint/tendermint/rpc/grpc"
 	rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server"
 	"github.com/tendermint/tendermint/types"
 
@@ -869,35 +868,7 @@ func (n *nodeImpl) startRPC() ([]net.Listener, error) {
 		listeners[i] = listener
 	}
 
-	// we expose a simplified api over grpc for convenience to app devs
-	grpcListenAddr := n.config.RPC.GRPCListenAddress
-	if grpcListenAddr != "" {
-		cfg := rpcserver.DefaultConfig()
-		cfg.MaxBodyBytes = n.config.RPC.MaxBodyBytes
-		cfg.MaxHeaderBytes = n.config.RPC.MaxHeaderBytes
-		// NOTE: GRPCMaxOpenConnections is used, not MaxOpenConnections
-		cfg.MaxOpenConnections = n.config.RPC.GRPCMaxOpenConnections
-		// If necessary adjust global WriteTimeout to ensure it's greater than
-		// TimeoutBroadcastTxCommit.
-		// See https://github.com/tendermint/tendermint/issues/3435
-		if cfg.WriteTimeout <= n.config.RPC.TimeoutBroadcastTxCommit {
-			cfg.WriteTimeout = n.config.RPC.TimeoutBroadcastTxCommit + 1*time.Second
-		}
-		listener, err := rpcserver.Listen(grpcListenAddr, cfg.MaxOpenConnections)
-		if err != nil {
-			return nil, err
-		}
-		go func() {
-			if err := grpccore.StartGRPCServer(n.rpcEnv, listener); err != nil {
-				n.Logger.Error("Error starting gRPC server", "err", err)
-			}
-		}()
-		listeners = append(listeners, listener)
-
-	}
-
 	return listeners, nil
-
 }
 
 // startPrometheusServer starts a Prometheus HTTP server, listening for metrics
diff --git a/proto/tendermint/rpc/grpc/types.proto b/proto/tendermint/rpc/grpc/types.proto
deleted file mode 100644
index ee948a4065..0000000000
--- a/proto/tendermint/rpc/grpc/types.proto
+++ /dev/null
@@ -1,32 +0,0 @@
-syntax = "proto3";
-package tendermint.rpc.grpc;
-option  go_package = "github.com/tendermint/tendermint/rpc/grpc;coregrpc";
-
-import "tendermint/abci/types.proto";
-
-//----------------------------------------
-// Request types
-
-message RequestPing {}
-
-message RequestBroadcastTx {
-  bytes tx = 1;
-}
-
-//----------------------------------------
-// Response types
-
-message ResponsePing {}
-
-message ResponseBroadcastTx {
-  tendermint.abci.ResponseCheckTx   check_tx   = 1;
-  tendermint.abci.ResponseDeliverTx deliver_tx = 2;
-}
-
-//----------------------------------------
-// Service Definition
-
-service BroadcastAPI {
-  rpc Ping(RequestPing) returns (ResponsePing);
-  rpc BroadcastTx(RequestBroadcastTx) returns (ResponseBroadcastTx);
-}
diff --git a/rpc/grpc/api.go b/rpc/grpc/api.go
deleted file mode 100644
index 4a4a136877..0000000000
--- a/rpc/grpc/api.go
+++ /dev/null
@@ -1,41 +0,0 @@
-package coregrpc
-
-import (
-	"context"
-
-	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/internal/rpc/core"
-	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
-)
-
-type broadcastAPI struct {
-	env *core.Environment
-}
-
-func (bapi *broadcastAPI) Ping(ctx context.Context, req *RequestPing) (*ResponsePing, error) {
-	// kvstore so we can check if the server is up
-	return &ResponsePing{}, nil
-}
-
-// Deprecated: gRPC  in the RPC layer of Tendermint will be removed in 0.36.
-func (bapi *broadcastAPI) BroadcastTx(ctx context.Context, req *RequestBroadcastTx) (*ResponseBroadcastTx, error) {
-	// NOTE: there's no way to get client's remote address
-	// see https://stackoverflow.com/questions/33684570/session-and-remote-ip-address-in-grpc-go
-	res, err := bapi.env.BroadcastTxCommit(&rpctypes.Context{}, req.Tx)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ResponseBroadcastTx{
-		CheckTx: &abci.ResponseCheckTx{
-			Code: res.CheckTx.Code,
-			Data: res.CheckTx.Data,
-			Log:  res.CheckTx.Log,
-		},
-		DeliverTx: &abci.ResponseDeliverTx{
-			Code: res.DeliverTx.Code,
-			Data: res.DeliverTx.Data,
-			Log:  res.DeliverTx.Log,
-		},
-	}, nil
-}
diff --git a/rpc/grpc/client_server.go b/rpc/grpc/client_server.go
deleted file mode 100644
index e5164dc64e..0000000000
--- a/rpc/grpc/client_server.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package coregrpc
-
-import (
-	"context"
-	"net"
-
-	"google.golang.org/grpc"
-
-	"github.com/tendermint/tendermint/internal/rpc/core"
-	tmnet "github.com/tendermint/tendermint/libs/net"
-)
-
-// Config is an gRPC server configuration.
-type Config struct {
-	MaxOpenConnections int
-}
-
-// StartGRPCServer starts a new gRPC BroadcastAPIServer using the given
-// net.Listener.
-// NOTE: This function blocks - you may want to call it in a go-routine.
-// Deprecated: gRPC  in the RPC layer of Tendermint will be removed in 0.36
-func StartGRPCServer(env *core.Environment, ln net.Listener) error {
-	grpcServer := grpc.NewServer()
-	RegisterBroadcastAPIServer(grpcServer, &broadcastAPI{env: env})
-	return grpcServer.Serve(ln)
-}
-
-// StartGRPCClient dials the gRPC server using protoAddr and returns a new
-// BroadcastAPIClient.
-func StartGRPCClient(protoAddr string) BroadcastAPIClient {
-	conn, err := grpc.Dial(protoAddr, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
-	if err != nil {
-		panic(err)
-	}
-	return NewBroadcastAPIClient(conn)
-}
-
-func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
-	return tmnet.Connect(addr)
-}
diff --git a/rpc/grpc/grpc_test.go b/rpc/grpc/grpc_test.go
deleted file mode 100644
index e680d195e9..0000000000
--- a/rpc/grpc/grpc_test.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package coregrpc_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/tendermint/tendermint/abci/example/kvstore"
-	"github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/libs/service"
-	coregrpc "github.com/tendermint/tendermint/rpc/grpc"
-	rpctest "github.com/tendermint/tendermint/rpc/test"
-)
-
-func NodeSuite(t *testing.T) (service.Service, *config.Config) {
-	t.Helper()
-
-	ctx, cancel := context.WithCancel(context.Background())
-
-	conf := rpctest.CreateConfig(t.Name())
-
-	// start a tendermint node in the background to test against
-	app := kvstore.NewApplication()
-
-	node, closer, err := rpctest.StartTendermint(ctx, conf, app)
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		_ = closer(ctx)
-		cancel()
-	})
-	return node, conf
-}
-
-func TestBroadcastTx(t *testing.T) {
-	_, conf := NodeSuite(t)
-
-	res, err := rpctest.GetGRPCClient(conf).BroadcastTx(
-		context.Background(),
-		&coregrpc.RequestBroadcastTx{Tx: []byte("this is a tx")},
-	)
-	require.NoError(t, err)
-	require.EqualValues(t, 0, res.CheckTx.Code)
-	require.EqualValues(t, 0, res.DeliverTx.Code)
-}
diff --git a/rpc/grpc/types.pb.go b/rpc/grpc/types.pb.go
deleted file mode 100644
index b9cbee03fc..0000000000
--- a/rpc/grpc/types.pb.go
+++ /dev/null
@@ -1,924 +0,0 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
-// source: tendermint/rpc/grpc/types.proto
-
-package coregrpc
-
-import (
-	context "context"
-	fmt "fmt"
-	proto "github.com/gogo/protobuf/proto"
-	types "github.com/tendermint/tendermint/abci/types"
-	grpc "google.golang.org/grpc"
-	codes "google.golang.org/grpc/codes"
-	status "google.golang.org/grpc/status"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
-
-type RequestPing struct {
-}
-
-func (m *RequestPing) Reset()         { *m = RequestPing{} }
-func (m *RequestPing) String() string { return proto.CompactTextString(m) }
-func (*RequestPing) ProtoMessage()    {}
-func (*RequestPing) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0ffff5682c662b95, []int{0}
-}
-func (m *RequestPing) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *RequestPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_RequestPing.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *RequestPing) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RequestPing.Merge(m, src)
-}
-func (m *RequestPing) XXX_Size() int {
-	return m.Size()
-}
-func (m *RequestPing) XXX_DiscardUnknown() {
-	xxx_messageInfo_RequestPing.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RequestPing proto.InternalMessageInfo
-
-type RequestBroadcastTx struct {
-	Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
-}
-
-func (m *RequestBroadcastTx) Reset()         { *m = RequestBroadcastTx{} }
-func (m *RequestBroadcastTx) String() string { return proto.CompactTextString(m) }
-func (*RequestBroadcastTx) ProtoMessage()    {}
-func (*RequestBroadcastTx) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0ffff5682c662b95, []int{1}
-}
-func (m *RequestBroadcastTx) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *RequestBroadcastTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_RequestBroadcastTx.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *RequestBroadcastTx) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_RequestBroadcastTx.Merge(m, src)
-}
-func (m *RequestBroadcastTx) XXX_Size() int {
-	return m.Size()
-}
-func (m *RequestBroadcastTx) XXX_DiscardUnknown() {
-	xxx_messageInfo_RequestBroadcastTx.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RequestBroadcastTx proto.InternalMessageInfo
-
-func (m *RequestBroadcastTx) GetTx() []byte {
-	if m != nil {
-		return m.Tx
-	}
-	return nil
-}
-
-type ResponsePing struct {
-}
-
-func (m *ResponsePing) Reset()         { *m = ResponsePing{} }
-func (m *ResponsePing) String() string { return proto.CompactTextString(m) }
-func (*ResponsePing) ProtoMessage()    {}
-func (*ResponsePing) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0ffff5682c662b95, []int{2}
-}
-func (m *ResponsePing) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ResponsePing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ResponsePing.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *ResponsePing) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResponsePing.Merge(m, src)
-}
-func (m *ResponsePing) XXX_Size() int {
-	return m.Size()
-}
-func (m *ResponsePing) XXX_DiscardUnknown() {
-	xxx_messageInfo_ResponsePing.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ResponsePing proto.InternalMessageInfo
-
-type ResponseBroadcastTx struct {
-	CheckTx   *types.ResponseCheckTx   `protobuf:"bytes,1,opt,name=check_tx,json=checkTx,proto3" json:"check_tx,omitempty"`
-	DeliverTx *types.ResponseDeliverTx `protobuf:"bytes,2,opt,name=deliver_tx,json=deliverTx,proto3" json:"deliver_tx,omitempty"`
-}
-
-func (m *ResponseBroadcastTx) Reset()         { *m = ResponseBroadcastTx{} }
-func (m *ResponseBroadcastTx) String() string { return proto.CompactTextString(m) }
-func (*ResponseBroadcastTx) ProtoMessage()    {}
-func (*ResponseBroadcastTx) Descriptor() ([]byte, []int) {
-	return fileDescriptor_0ffff5682c662b95, []int{3}
-}
-func (m *ResponseBroadcastTx) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ResponseBroadcastTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ResponseBroadcastTx.Marshal(b, m, deterministic)
-	} else {
-		b = b[:cap(b)]
-		n, err := m.MarshalToSizedBuffer(b)
-		if err != nil {
-			return nil, err
-		}
-		return b[:n], nil
-	}
-}
-func (m *ResponseBroadcastTx) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ResponseBroadcastTx.Merge(m, src)
-}
-func (m *ResponseBroadcastTx) XXX_Size() int {
-	return m.Size()
-}
-func (m *ResponseBroadcastTx) XXX_DiscardUnknown() {
-	xxx_messageInfo_ResponseBroadcastTx.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ResponseBroadcastTx proto.InternalMessageInfo
-
-func (m *ResponseBroadcastTx) GetCheckTx() *types.ResponseCheckTx {
-	if m != nil {
-		return m.CheckTx
-	}
-	return nil
-}
-
-func (m *ResponseBroadcastTx) GetDeliverTx() *types.ResponseDeliverTx {
-	if m != nil {
-		return m.DeliverTx
-	}
-	return nil
-}
-
-func init() {
-	proto.RegisterType((*RequestPing)(nil), "tendermint.rpc.grpc.RequestPing")
-	proto.RegisterType((*RequestBroadcastTx)(nil), "tendermint.rpc.grpc.RequestBroadcastTx")
-	proto.RegisterType((*ResponsePing)(nil), "tendermint.rpc.grpc.ResponsePing")
-	proto.RegisterType((*ResponseBroadcastTx)(nil), "tendermint.rpc.grpc.ResponseBroadcastTx")
-}
-
-func init() { proto.RegisterFile("tendermint/rpc/grpc/types.proto", fileDescriptor_0ffff5682c662b95) }
-
-var fileDescriptor_0ffff5682c662b95 = []byte{
-	// 316 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2f, 0x49, 0xcd, 0x4b,
-	0x49, 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x2f, 0x2a, 0x48, 0xd6, 0x4f, 0x07, 0x11, 0x25, 0x95,
-	0x05, 0xa9, 0xc5, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xc2, 0x08, 0x05, 0x7a, 0x45, 0x05,
-	0xc9, 0x7a, 0x20, 0x05, 0x52, 0xd2, 0x48, 0xba, 0x12, 0x93, 0x92, 0x33, 0x91, 0x75, 0x28, 0xf1,
-	0x72, 0x71, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x04, 0x64, 0xe6, 0xa5, 0x2b, 0xa9, 0x70,
-	0x09, 0x41, 0xb9, 0x4e, 0x45, 0xf9, 0x89, 0x29, 0xc9, 0x89, 0xc5, 0x25, 0x21, 0x15, 0x42, 0x7c,
-	0x5c, 0x4c, 0x25, 0x15, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c, 0x41, 0x4c, 0x25, 0x15, 0x4a, 0x7c,
-	0x5c, 0x3c, 0x41, 0xa9, 0xc5, 0x05, 0xf9, 0x79, 0xc5, 0xa9, 0x60, 0x5d, 0x53, 0x19, 0xb9, 0x84,
-	0x61, 0x02, 0xc8, 0xfa, 0xac, 0xb9, 0x38, 0x92, 0x33, 0x52, 0x93, 0xb3, 0xe3, 0xa1, 0xba, 0xb9,
-	0x8d, 0x14, 0xf4, 0x90, 0x5c, 0x08, 0x72, 0x8c, 0x1e, 0x4c, 0x9f, 0x33, 0x48, 0x61, 0x48, 0x45,
-	0x10, 0x7b, 0x32, 0x84, 0x21, 0xe4, 0xc8, 0xc5, 0x95, 0x92, 0x9a, 0x93, 0x59, 0x96, 0x5a, 0x04,
-	0xd2, 0xce, 0x04, 0xd6, 0xae, 0x84, 0x53, 0xbb, 0x0b, 0x44, 0x69, 0x48, 0x45, 0x10, 0x67, 0x0a,
-	0x8c, 0x69, 0xb4, 0x97, 0x91, 0x8b, 0x07, 0xee, 0x1e, 0xc7, 0x00, 0x4f, 0x21, 0x6f, 0x2e, 0x16,
-	0x90, 0x83, 0x85, 0x50, 0x9c, 0x01, 0x0b, 0x28, 0x3d, 0xa4, 0x80, 0x90, 0x52, 0xc4, 0xa1, 0x02,
-	0xe1, 0x6b, 0xa1, 0x04, 0x2e, 0x6e, 0x64, 0xcf, 0xaa, 0xe3, 0x33, 0x13, 0x49, 0xa1, 0x94, 0x06,
-	0x5e, 0xa3, 0x91, 0x54, 0x3a, 0xf9, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83,
-	0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43,
-	0x94, 0x51, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x52, 0xf4, 0x62,
-	0x49, 0x1f, 0xd6, 0xc9, 0xf9, 0x45, 0xa9, 0x20, 0x46, 0x12, 0x1b, 0x38, 0xc6, 0x8d, 0x01, 0x01,
-	0x00, 0x00, 0xff, 0xff, 0xf6, 0x4b, 0x02, 0xd8, 0x46, 0x02, 0x00, 0x00,
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// BroadcastAPIClient is the client API for BroadcastAPI service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type BroadcastAPIClient interface {
-	Ping(ctx context.Context, in *RequestPing, opts ...grpc.CallOption) (*ResponsePing, error)
-	BroadcastTx(ctx context.Context, in *RequestBroadcastTx, opts ...grpc.CallOption) (*ResponseBroadcastTx, error)
-}
-
-type broadcastAPIClient struct {
-	cc *grpc.ClientConn
-}
-
-func NewBroadcastAPIClient(cc *grpc.ClientConn) BroadcastAPIClient {
-	return &broadcastAPIClient{cc}
-}
-
-func (c *broadcastAPIClient) Ping(ctx context.Context, in *RequestPing, opts ...grpc.CallOption) (*ResponsePing, error) {
-	out := new(ResponsePing)
-	err := c.cc.Invoke(ctx, "/tendermint.rpc.grpc.BroadcastAPI/Ping", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *broadcastAPIClient) BroadcastTx(ctx context.Context, in *RequestBroadcastTx, opts ...grpc.CallOption) (*ResponseBroadcastTx, error) {
-	out := new(ResponseBroadcastTx)
-	err := c.cc.Invoke(ctx, "/tendermint.rpc.grpc.BroadcastAPI/BroadcastTx", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// BroadcastAPIServer is the server API for BroadcastAPI service.
-type BroadcastAPIServer interface {
-	Ping(context.Context, *RequestPing) (*ResponsePing, error)
-	BroadcastTx(context.Context, *RequestBroadcastTx) (*ResponseBroadcastTx, error)
-}
-
-// UnimplementedBroadcastAPIServer can be embedded to have forward compatible implementations.
-type UnimplementedBroadcastAPIServer struct {
-}
-
-func (*UnimplementedBroadcastAPIServer) Ping(ctx context.Context, req *RequestPing) (*ResponsePing, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
-}
-func (*UnimplementedBroadcastAPIServer) BroadcastTx(ctx context.Context, req *RequestBroadcastTx) (*ResponseBroadcastTx, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method BroadcastTx not implemented")
-}
-
-func RegisterBroadcastAPIServer(s *grpc.Server, srv BroadcastAPIServer) {
-	s.RegisterService(&_BroadcastAPI_serviceDesc, srv)
-}
-
-func _BroadcastAPI_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(RequestPing)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BroadcastAPIServer).Ping(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/tendermint.rpc.grpc.BroadcastAPI/Ping",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BroadcastAPIServer).Ping(ctx, req.(*RequestPing))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _BroadcastAPI_BroadcastTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(RequestBroadcastTx)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(BroadcastAPIServer).BroadcastTx(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/tendermint.rpc.grpc.BroadcastAPI/BroadcastTx",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(BroadcastAPIServer).BroadcastTx(ctx, req.(*RequestBroadcastTx))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-var _BroadcastAPI_serviceDesc = grpc.ServiceDesc{
-	ServiceName: "tendermint.rpc.grpc.BroadcastAPI",
-	HandlerType: (*BroadcastAPIServer)(nil),
-	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Ping",
-			Handler:    _BroadcastAPI_Ping_Handler,
-		},
-		{
-			MethodName: "BroadcastTx",
-			Handler:    _BroadcastAPI_BroadcastTx_Handler,
-		},
-	},
-	Streams:  []grpc.StreamDesc{},
-	Metadata: "tendermint/rpc/grpc/types.proto",
-}
-
-func (m *RequestPing) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *RequestPing) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *RequestPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *RequestBroadcastTx) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *RequestBroadcastTx) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *RequestBroadcastTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if len(m.Tx) > 0 {
-		i -= len(m.Tx)
-		copy(dAtA[i:], m.Tx)
-		i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func (m *ResponsePing) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *ResponsePing) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ResponsePing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	return len(dAtA) - i, nil
-}
-
-func (m *ResponseBroadcastTx) Marshal() (dAtA []byte, err error) {
-	size := m.Size()
-	dAtA = make([]byte, size)
-	n, err := m.MarshalToSizedBuffer(dAtA[:size])
-	if err != nil {
-		return nil, err
-	}
-	return dAtA[:n], nil
-}
-
-func (m *ResponseBroadcastTx) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ResponseBroadcastTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	if m.DeliverTx != nil {
-		{
-			size, err := m.DeliverTx.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTypes(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0x12
-	}
-	if m.CheckTx != nil {
-		{
-			size, err := m.CheckTx.MarshalToSizedBuffer(dAtA[:i])
-			if err != nil {
-				return 0, err
-			}
-			i -= size
-			i = encodeVarintTypes(dAtA, i, uint64(size))
-		}
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
-func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
-	offset -= sovTypes(v)
-	base := offset
-	for v >= 1<<7 {
-		dAtA[offset] = uint8(v&0x7f | 0x80)
-		v >>= 7
-		offset++
-	}
-	dAtA[offset] = uint8(v)
-	return base
-}
-func (m *RequestPing) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *RequestBroadcastTx) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Tx)
-	if l > 0 {
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	return n
-}
-
-func (m *ResponsePing) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	return n
-}
-
-func (m *ResponseBroadcastTx) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	if m.CheckTx != nil {
-		l = m.CheckTx.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	if m.DeliverTx != nil {
-		l = m.DeliverTx.Size()
-		n += 1 + l + sovTypes(uint64(l))
-	}
-	return n
-}
-
-func sovTypes(x uint64) (n int) {
-	return (math_bits.Len64(x|1) + 6) / 7
-}
-func sozTypes(x uint64) (n int) {
-	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
-}
-func (m *RequestPing) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: RequestPing: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RequestPing: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *RequestBroadcastTx) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: RequestBroadcastTx: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RequestBroadcastTx: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType)
-			}
-			var byteLen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				byteLen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if byteLen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + byteLen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...)
-			if m.Tx == nil {
-				m.Tx = []byte{}
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ResponsePing) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: ResponsePing: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ResponsePing: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func (m *ResponseBroadcastTx) Unmarshal(dAtA []byte) error {
-	l := len(dAtA)
-	iNdEx := 0
-	for iNdEx < l {
-		preIndex := iNdEx
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= uint64(b&0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		fieldNum := int32(wire >> 3)
-		wireType := int(wire & 0x7)
-		if wireType == 4 {
-			return fmt.Errorf("proto: ResponseBroadcastTx: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ResponseBroadcastTx: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.CheckTx == nil {
-				m.CheckTx = &types.ResponseCheckTx{}
-			}
-			if err := m.CheckTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType)
-			}
-			var msglen int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				msglen |= int(b&0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if msglen < 0 {
-				return ErrInvalidLengthTypes
-			}
-			postIndex := iNdEx + msglen
-			if postIndex < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if postIndex > l {
-				return io.ErrUnexpectedEOF
-			}
-			if m.DeliverTx == nil {
-				m.DeliverTx = &types.ResponseDeliverTx{}
-			}
-			if err := m.DeliverTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
-			iNdEx = postIndex
-		default:
-			iNdEx = preIndex
-			skippy, err := skipTypes(dAtA[iNdEx:])
-			if err != nil {
-				return err
-			}
-			if (skippy < 0) || (iNdEx+skippy) < 0 {
-				return ErrInvalidLengthTypes
-			}
-			if (iNdEx + skippy) > l {
-				return io.ErrUnexpectedEOF
-			}
-			iNdEx += skippy
-		}
-	}
-
-	if iNdEx > l {
-		return io.ErrUnexpectedEOF
-	}
-	return nil
-}
-func skipTypes(dAtA []byte) (n int, err error) {
-	l := len(dAtA)
-	iNdEx := 0
-	depth := 0
-	for iNdEx < l {
-		var wire uint64
-		for shift := uint(0); ; shift += 7 {
-			if shift >= 64 {
-				return 0, ErrIntOverflowTypes
-			}
-			if iNdEx >= l {
-				return 0, io.ErrUnexpectedEOF
-			}
-			b := dAtA[iNdEx]
-			iNdEx++
-			wire |= (uint64(b) & 0x7F) << shift
-			if b < 0x80 {
-				break
-			}
-		}
-		wireType := int(wire & 0x7)
-		switch wireType {
-		case 0:
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				iNdEx++
-				if dAtA[iNdEx-1] < 0x80 {
-					break
-				}
-			}
-		case 1:
-			iNdEx += 8
-		case 2:
-			var length int
-			for shift := uint(0); ; shift += 7 {
-				if shift >= 64 {
-					return 0, ErrIntOverflowTypes
-				}
-				if iNdEx >= l {
-					return 0, io.ErrUnexpectedEOF
-				}
-				b := dAtA[iNdEx]
-				iNdEx++
-				length |= (int(b) & 0x7F) << shift
-				if b < 0x80 {
-					break
-				}
-			}
-			if length < 0 {
-				return 0, ErrInvalidLengthTypes
-			}
-			iNdEx += length
-		case 3:
-			depth++
-		case 4:
-			if depth == 0 {
-				return 0, ErrUnexpectedEndOfGroupTypes
-			}
-			depth--
-		case 5:
-			iNdEx += 4
-		default:
-			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
-		}
-		if iNdEx < 0 {
-			return 0, ErrInvalidLengthTypes
-		}
-		if depth == 0 {
-			return iNdEx, nil
-		}
-	}
-	return 0, io.ErrUnexpectedEOF
-}
-
-var (
-	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
-	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
-	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
-)
diff --git a/rpc/test/helpers.go b/rpc/test/helpers.go
index e2f47839c2..189289b0a8 100644
--- a/rpc/test/helpers.go
+++ b/rpc/test/helpers.go
@@ -14,7 +14,6 @@ import (
 	"github.com/tendermint/tendermint/libs/service"
 	"github.com/tendermint/tendermint/node"
 	"github.com/tendermint/tendermint/rpc/coretypes"
-	coregrpc "github.com/tendermint/tendermint/rpc/grpc"
 	rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client"
 )
 
@@ -24,6 +23,7 @@ type Options struct {
 	suppressStdout bool
 }
 
+// waitForRPC connects to the RPC service and blocks until a /status call succeeds.
 func waitForRPC(ctx context.Context, conf *config.Config) {
 	laddr := conf.RPC.ListenAddress
 	client, err := rpcclient.New(laddr)
@@ -42,16 +42,6 @@ func waitForRPC(ctx context.Context, conf *config.Config) {
 	}
 }
 
-func waitForGRPC(ctx context.Context, conf *config.Config) {
-	client := GetGRPCClient(conf)
-	for {
-		_, err := client.Ping(ctx, &coregrpc.RequestPing{})
-		if err == nil {
-			return
-		}
-	}
-}
-
 func randPort() int {
 	port, err := tmnet.GetFreePort()
 	if err != nil {
@@ -60,30 +50,24 @@ func randPort() int {
 	return port
 }
 
-func makeAddrs() (string, string, string) {
-	return fmt.Sprintf("tcp://127.0.0.1:%d", randPort()),
-		fmt.Sprintf("tcp://127.0.0.1:%d", randPort()),
-		fmt.Sprintf("tcp://127.0.0.1:%d", randPort())
+// makeAddrs constructs local listener addresses for node services.  This
+// implementation uses random ports so test instances can run concurrently.
+func makeAddrs() (p2pAddr, rpcAddr string) {
+	const addrTemplate = "tcp://127.0.0.1:%d"
+	return fmt.Sprintf(addrTemplate, randPort()), fmt.Sprintf(addrTemplate, randPort())
 }
 
 func CreateConfig(testName string) *config.Config {
 	c := config.ResetTestRoot(testName)
 
-	// and we use random ports to run in parallel
-	tm, rpc, grpc := makeAddrs()
-	c.P2P.ListenAddress = tm
-	c.RPC.ListenAddress = rpc
+	p2pAddr, rpcAddr := makeAddrs()
+	c.P2P.ListenAddress = p2pAddr
+	c.RPC.ListenAddress = rpcAddr
 	c.Consensus.WalPath = "rpc-test"
 	c.RPC.CORSAllowedOrigins = []string{"https://tendermint.com/"}
-	c.RPC.GRPCListenAddress = grpc
 	return c
 }
 
-func GetGRPCClient(conf *config.Config) coregrpc.BroadcastAPIClient {
-	grpcAddr := conf.RPC.GRPCListenAddress
-	return coregrpc.StartGRPCClient(grpcAddr)
-}
-
 type ServiceCloser func(context.Context) error
 
 func StartTendermint(ctx context.Context,
@@ -112,9 +96,7 @@ func StartTendermint(ctx context.Context,
 		return nil, func(_ context.Context) error { return nil }, err
 	}
 
-	// wait for rpc
 	waitForRPC(ctx, conf)
-	waitForGRPC(ctx, conf)
 
 	if !nodeOpts.suppressStdout {
 		fmt.Println("Tendermint running!")
diff --git a/test/app/grpc_client.go b/test/app/grpc_client.go
deleted file mode 100644
index 73022aaf83..0000000000
--- a/test/app/grpc_client.go
+++ /dev/null
@@ -1,42 +0,0 @@
-package main
-
-import (
-	"encoding/hex"
-	"fmt"
-	"os"
-
-	"context"
-
-	tmjson "github.com/tendermint/tendermint/libs/json"
-	coregrpc "github.com/tendermint/tendermint/rpc/grpc"
-)
-
-var grpcAddr = "tcp://localhost:36656"
-
-func main() {
-	args := os.Args
-	if len(args) == 1 {
-		fmt.Println("Must enter a transaction to send (hex)")
-		os.Exit(1)
-	}
-	tx := args[1]
-	txBytes, err := hex.DecodeString(tx)
-	if err != nil {
-		fmt.Println("Invalid hex", err)
-		os.Exit(1)
-	}
-
-	clientGRPC := coregrpc.StartGRPCClient(grpcAddr)
-	res, err := clientGRPC.BroadcastTx(context.Background(), &coregrpc.RequestBroadcastTx{Tx: txBytes})
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	bz, err := tmjson.Marshal(res)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	fmt.Println(string(bz))
-}

From bc1a20dbb86e4fa2120b2c8a9de88814471f4a2c Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Wed, 13 Oct 2021 16:37:50 -0700
Subject: [PATCH 48/57] Revert temporary patch to buf.yaml. (#7122)

This patch was needed to pass the buf breakage check for the proto file removed
in #7121, but now that master contains the change we no longer need the patch.
---
 buf.yaml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/buf.yaml b/buf.yaml
index 98feb708e2..cc4aced576 100644
--- a/buf.yaml
+++ b/buf.yaml
@@ -14,6 +14,3 @@ lint:
 breaking:
   use:
     - FILE
-  ignore:
-    # TODO(#7075): Remove after file deletion is merged.
-    - tendermint/rpc

From b95c26198163335999e746c8cacbe29cab6b01a1 Mon Sep 17 00:00:00 2001
From: Jared Zhou <zjj1149@gmail.com>
Date: Thu, 14 Oct 2021 16:34:25 +0800
Subject: [PATCH 49/57] rpc: fix typo in broadcast commit (#7124)

---
 internal/rpc/core/mempool.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/rpc/core/mempool.go b/internal/rpc/core/mempool.go
index c20f020328..5b12a6c2bc 100644
--- a/internal/rpc/core/mempool.go
+++ b/internal/rpc/core/mempool.go
@@ -78,7 +78,7 @@ func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*
 				CheckTx: *r,
 				Hash:    tx.Hash(),
 			},
-			errors.New("cannot wait for commit because kvEventSync is not enabled")
+			errors.New("cannot confirm transaction because kvEventSink is not enabled")
 	}
 
 	startAt := time.Now()

From c3dc7d20df6d32c8087f2cf01f7817d47273bd19 Mon Sep 17 00:00:00 2001
From: Callum Waters <cmwaters19@gmail.com>
Date: Fri, 15 Oct 2021 10:35:36 +0200
Subject: [PATCH 50/57] docs: add roadmap to repo (#7107)

---
 README.md                                     |   4 +
 docs/.vuepress/config.js                      |   4 -
 docs/app-dev/readme.md                        |   5 +-
 docs/networks/README.md                       |  16 ---
 docs/nodes/README.md                          |   2 +-
 docs/roadmap/roadmap.md                       | 100 ++++++++++++++++++
 docs/tendermint-core/README.md                |   5 +-
 docs/tools/README.md                          |   8 ++
 docs/{networks => tools}/docker-compose.md    |   0
 .../terraform-and-ansible.md                  |   0
 docs/tutorials/readme.md                      |   2 +-
 11 files changed, 119 insertions(+), 27 deletions(-)
 delete mode 100644 docs/networks/README.md
 create mode 100644 docs/roadmap/roadmap.md
 rename docs/{networks => tools}/docker-compose.md (100%)
 rename docs/{networks => tools}/terraform-and-ansible.md (100%)

diff --git a/README.md b/README.md
index 3157a148e4..f0da8f4845 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,8 @@ See below for more details about [versioning](#versioning).
 In any case, if you intend to run Tendermint in production, we're happy to help. You can
 contact us [over email](mailto:hello@interchain.berlin) or [join the chat](https://discord.gg/cosmosnetwork).
 
+More on how releases are conducted can be found [here](./RELEASES.md).
+
 ## Security
 
 To report a security vulnerability, see our [bug bounty
@@ -112,6 +114,8 @@ in [UPGRADING.md](./UPGRADING.md).
 
 ### Tendermint Core
 
+We keep a public up-to-date version of our roadmap [here](./docs/roadmap/roadmap.md)
+
 For details about the blockchain data structures and the p2p protocols, see the
 [Tendermint specification](https://docs.tendermint.com/master/spec/).
 
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index f453dc1ef0..4653e2c5b1 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -48,10 +48,6 @@ module.exports = {
         {
           title: 'Resources',
           children: [
-            {
-              title: 'Developer Sessions',
-              path: '/DEV_SESSIONS.html'
-            },
             {
               title: 'RPC',
               path: 'https://docs.tendermint.com/master/rpc/',
diff --git a/docs/app-dev/readme.md b/docs/app-dev/readme.md
index 51e88fc34a..46ce06ca00 100644
--- a/docs/app-dev/readme.md
+++ b/docs/app-dev/readme.md
@@ -1,7 +1,6 @@
 ---
 order: false
 parent:
+  title: "Building Applications"
   order: 3
----
-
-# Apps
+---
\ No newline at end of file
diff --git a/docs/networks/README.md b/docs/networks/README.md
deleted file mode 100644
index 0b14e391be..0000000000
--- a/docs/networks/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-order: 1
-parent:
-  title: Networks
-  order: 1
----
-
-# Overview
-
-Use [Docker Compose](./docker-compose.md) to spin up Tendermint testnets on your
-local machine.
-
-Use [Terraform and Ansible](./terraform-and-ansible.md) to deploy Tendermint
-testnets to the cloud.
-
-See the `tendermint testnet --help` command for more help initializing testnets.
diff --git a/docs/nodes/README.md b/docs/nodes/README.md
index 9be6febf03..fd9056e0dd 100644
--- a/docs/nodes/README.md
+++ b/docs/nodes/README.md
@@ -1,7 +1,7 @@
 ---
 order: 1
 parent:
-  title: Nodes
+  title: Node Operators
   order: 4
 ---
 
diff --git a/docs/roadmap/roadmap.md b/docs/roadmap/roadmap.md
new file mode 100644
index 0000000000..e6e5a32fe3
--- /dev/null
+++ b/docs/roadmap/roadmap.md
@@ -0,0 +1,100 @@
+---
+order: false
+parent:
+  title: Roadmap
+  order: 7
+---
+
+# Tendermint Roadmap
+
+*Last Updated: Friday 8 October 2021*
+
+This document endeavours to inform the wider Tendermint community about development plans and priorities for Tendermint Core, and when we expect features to be delivered. It is intended to broadly inform all users of Tendermint, including application developers, node operators, integrators, and the engineering and research teams.
+
+Anyone wishing to propose work to be a part of this roadmap should do so by opening an [issue](https://github.com/tendermint/spec/issues/new/choose) in the spec. Bug reports and other implementation concerns should be brought up in the [core repository](https://github.com/tendermint/tendermint).
+
+This roadmap should be read as a high-level guide to plans and priorities, rather than a commitment to schedules and deliverables. Features earlier on the roadmap will generally be more specific and detailed than those later on. We will update this document periodically to reflect the current status.
+
+The upgrades are split into two components: **Epics**, the features that define a release and to a large part dictate the timing of releases; and **minors**, features of smaller scale and lower priority, that could land in neighboring releases.
+
+## V0.35 (completed Q3 2021)
+
+### Prioritized Mempool
+
+Transactions were previously added to blocks in the order with which they arrived to the mempool. Adding a priority field via `CheckTx` gives applications more control over which transactions make it into a block. This is important in the presence of transaction fees. [More](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-067-mempool-refactor.md)
+
+### Refactor of the P2P Framework
+
+The Tendermint P2P system is undergoing a large redesign to improve its performance and reliability. The first phase of this redesign is included in 0.35. This phase cleans and decouples abstractions, improves peer lifecycle management, peer address handling and enables pluggable transports. It is implemented to be protocol-compatible with the previous implementation. [More](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-062-p2p-architecture.md)
+
+### State Sync Improvements
+
+Following the initial version of state sync, several improvements have been made. These include the addition of [Reverse Sync](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-068-reverse-sync.md) needed for evidence handling, the introduction of a [P2P State Provider](https://github.com/tendermint/tendermint/pull/6807) as an alternative to RPC endpoints, new configuration parameters to adjust throughput, and several bug fixes.
+
+### Custom event indexing + PSQL Indexer
+
+Added a new `EventSink` interface to allow alternatives to Tendermint's proprietary transaction indexer. We also added a PostgreSQL Indexer implementation, allowing rich SQL-based index queries. [More](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-065-custom-event-indexing.md)
+
+### Minor Works
+
+- Several Go packages were reorganized to make the distinction between public APIs and implementation details more clear.
+- Block indexer to index begin-block and end-block events. [More](https://github.com/tendermint/tendermint/pull/6226)
+- Block, state, evidence, and light storage keys were reworked to preserve lexicographic order. This change requires a database migration. [More](https://github.com/tendermint/tendermint/pull/5771)
+- Introduciton of Tendermint modes. Part of this change includes the possibility to run a separate seed node that runs the PEX reactor only. [More](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-052-tendermint-mode.md)
+
+## V0.36 (expected Q1 2022)
+
+### ABCI++
+
+An overhaul of the existing interface between the application and consensus, to give the application more control over block construction. ABCI++ adds new hooks allowing modification of transactions before they get into a block, verification of a block before voting, injection of signed information into votes, and more compact delivery of blocks after agreement (to allow for concurrent execution). [More](https://github.com/tendermint/spec/blob/master/rfc/004-abci%2B%2B.md)
+
+### Proposer-Based Timestamps
+
+Proposer-based timestamps are a replacement of [BFT time](https://docs.tendermint.com/master/spec/consensus/bft-time.html), whereby the proposer chooses a timestamp and validators vote on the block only if the timestamp is considered *timely*. This increases reliance on an accurate local clock, but in exchange makes block time more reliable and resistant to faults. This has important use cases in light clients, IBC relayers, CosmosHub inflation and enabling signature aggregation. [More](https://github.com/tendermint/tendermint/blob/master/docs/architecture/adr-071-proposer-based-timestamps.md)
+
+### Soft Upgrades
+
+We are working on a suite of tools and patterns to make it easier for both node operators and application developers to quickly and safely upgrade to newer versions of Tendermint. [More](https://github.com/tendermint/spec/pull/222)
+
+### Minor Works
+
+- Remove the "legacy" P2P framework, and clean up of P2P package. [More](https://github.com/tendermint/tendermint/issues/5670)
+- Remove the global mutex from the local ABCI client to enable application-controlled concurrency. [More](https://github.com/tendermint/tendermint/issues/7073)
+- Enable P2P support for light clients
+- Node orchestration of services + Node initialization and composibility
+- Remove redundancy in several data structures. Remove unused components such as the block sync v2 reactor, gRPC in the RPC layer, and the socket-based remote signer.
+- Improve node visibility by introducing more metrics
+
+## V0.37 (expected Q3 2022)
+
+### Complete P2P Refactor
+
+Finish the final phase of the P2P system. Ongoing research and planning is taking place to decide whether to adopt [libp2p](https://libp2p.io/), alternative transports to `MConn` such as [QUIC](https://en.wikipedia.org/wiki/QUIC) and handshake/authentication protocols such as [Noise](https://noiseprotocol.org/). Research into more advanced gossiping techniques.
+
+### Streamline Storage Engine
+
+Tendermint currently has an abstraction to allow support for multiple database backends. This generality incurs maintenance overhead and interferes with application-specific optimizations that Tendermint could use (ACID guarantees, etc.). We plan to converge on a single database and streamline the Tendermint storage engine. [More](https://github.com/tendermint/tendermint/pull/6897)
+
+### Evaluate Interprocess Communication
+
+Tendermint nodes currently have multiple areas of communication with other processes (ABCI, remote-signer, P2P, JSONRPC, websockets, events as examples). Many of these have multiple implementations in which a single suffices. Consolidate and clean up IPC. [More](https://github.com/tendermint/tendermint/blob/master/docs/rfc/rfc-002-ipc-ecosystem.md)
+
+### Minor Works
+
+- Amnesia attack handling. [More](https://github.com/tendermint/tendermint/issues/5270)
+- Remove / Update Consensus WAL. [More](https://github.com/tendermint/tendermint/issues/6397)
+- Signature Aggregation. [More](https://github.com/tendermint/tendermint/issues/1319)
+- Remove gogoproto dependency. [More](https://github.com/tendermint/tendermint/issues/5446)
+
+## V1.0 (expected Q4 2022)
+
+Has the same feature set as V0.37 but with a focus towards testing, protocol correctness and minor tweaks to ensure a stable product. Such work might include extending the [consensus testing framework](https://github.com/tendermint/tendermint/issues/5920), the use of canary/long-lived testnets and greater integration tests.
+
+## Post 1.0 Work
+
+- Improved block propagation with erasure coding and/or compact blocks. [More](https://github.com/tendermint/spec/issues/347)
+- Consensus engine refactor
+- Bidirectional ABCI
+- Randomized Leader Election
+- ZK proofs / other cryptographic primitives
+- Multichain Tendermint
diff --git a/docs/tendermint-core/README.md b/docs/tendermint-core/README.md
index fb359a08b2..f83349db28 100644
--- a/docs/tendermint-core/README.md
+++ b/docs/tendermint-core/README.md
@@ -1,7 +1,7 @@
 ---
 order: 1
 parent:
-  title: System
+  title: Understanding Tendermint
   order: 5
 ---
 
@@ -10,7 +10,6 @@ parent:
 This section dives into the internals of Go-Tendermint.
 
 - [Using Tendermint](./using-tendermint.md)
-- [Running in Production](./running-in-production.md)
 - [Subscribing to events](./subscription.md)
 - [Block Structure](./block-structure.md)
 - [RPC](./rpc.md)
@@ -18,3 +17,5 @@ This section dives into the internals of Go-Tendermint.
 - [State Sync](./state-sync.md)
 - [Mempool](./mempool.md)
 - [Light Client](./light-client.md)
+
+For full specifications refer to the [spec repo](https://github.com/tendermint/spec).
\ No newline at end of file
diff --git a/docs/tools/README.md b/docs/tools/README.md
index 3e87a2ea1f..5d778f4700 100644
--- a/docs/tools/README.md
+++ b/docs/tools/README.md
@@ -27,3 +27,11 @@ testing Tendermint networks.
 
 This repository contains various different configurations of test networks for,
 and relating to, Tendermint.
+
+Use [Docker Compose](./docker-compose.md) to spin up Tendermint testnets on your
+local machine.
+
+Use [Terraform and Ansible](./terraform-and-ansible.md) to deploy Tendermint
+testnets to the cloud.
+
+See the `tendermint testnet --help` command for more help initializing testnets.
diff --git a/docs/networks/docker-compose.md b/docs/tools/docker-compose.md
similarity index 100%
rename from docs/networks/docker-compose.md
rename to docs/tools/docker-compose.md
diff --git a/docs/networks/terraform-and-ansible.md b/docs/tools/terraform-and-ansible.md
similarity index 100%
rename from docs/networks/terraform-and-ansible.md
rename to docs/tools/terraform-and-ansible.md
diff --git a/docs/tutorials/readme.md b/docs/tutorials/readme.md
index a60fba3492..0216df800d 100644
--- a/docs/tutorials/readme.md
+++ b/docs/tutorials/readme.md
@@ -4,4 +4,4 @@ parent:
   order: 2
 ---
 
-# Guides
+# Tutorials

From 006e6108a121c50e482c8d2da551162d36b844a1 Mon Sep 17 00:00:00 2001
From: "M. J. Fromberger" <fromberger@interchain.io>
Date: Fri, 15 Oct 2021 05:18:53 -0700
Subject: [PATCH 51/57] Fix the protobuf generation script. (#7127)

This should have been part of #7121, but I missed it.
---
 scripts/protocgen.sh | 2 --
 1 file changed, 2 deletions(-)

diff --git a/scripts/protocgen.sh b/scripts/protocgen.sh
index 51b1cc6d33..1b84c2c568 100755
--- a/scripts/protocgen.sh
+++ b/scripts/protocgen.sh
@@ -5,5 +5,3 @@ set -eo pipefail
 buf generate --path proto/tendermint
 
 mv ./proto/tendermint/abci/types.pb.go ./abci/types
-
-mv ./proto/tendermint/rpc/grpc/types.pb.go ./rpc/grpc

From 66a11fe52795eaba6aacae3ca25206c380e5283a Mon Sep 17 00:00:00 2001
From: Marko <marbar3778@yahoo.com>
Date: Fri, 15 Oct 2021 13:03:53 +0000
Subject: [PATCH 52/57] blocksync: remove v0 folder structure (#7128)

Remove v0 blocksync folder structure.
---
 internal/blocksync/{v0 => }/pool.go         |  2 +-
 internal/blocksync/{v0 => }/pool_test.go    |  2 +-
 internal/blocksync/{v0 => }/reactor.go      |  5 ++---
 internal/blocksync/{v0 => }/reactor_test.go |  2 +-
 node/setup.go                               | 12 ++++++------
 5 files changed, 11 insertions(+), 12 deletions(-)
 rename internal/blocksync/{v0 => }/pool.go (99%)
 rename internal/blocksync/{v0 => }/pool_test.go (99%)
 rename internal/blocksync/{v0 => }/reactor.go (99%)
 rename internal/blocksync/{v0 => }/reactor_test.go (99%)

diff --git a/internal/blocksync/v0/pool.go b/internal/blocksync/pool.go
similarity index 99%
rename from internal/blocksync/v0/pool.go
rename to internal/blocksync/pool.go
index b3704f3333..d10a32b0d1 100644
--- a/internal/blocksync/v0/pool.go
+++ b/internal/blocksync/pool.go
@@ -1,4 +1,4 @@
-package v0
+package blocksync
 
 import (
 	"errors"
diff --git a/internal/blocksync/v0/pool_test.go b/internal/blocksync/pool_test.go
similarity index 99%
rename from internal/blocksync/v0/pool_test.go
rename to internal/blocksync/pool_test.go
index 67617d2b75..cbe19acbe4 100644
--- a/internal/blocksync/v0/pool_test.go
+++ b/internal/blocksync/pool_test.go
@@ -1,4 +1,4 @@
-package v0
+package blocksync
 
 import (
 	"fmt"
diff --git a/internal/blocksync/v0/reactor.go b/internal/blocksync/reactor.go
similarity index 99%
rename from internal/blocksync/v0/reactor.go
rename to internal/blocksync/reactor.go
index 552dcbda5d..0c193577eb 100644
--- a/internal/blocksync/v0/reactor.go
+++ b/internal/blocksync/reactor.go
@@ -1,4 +1,4 @@
-package v0
+package blocksync
 
 import (
 	"fmt"
@@ -6,7 +6,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/tendermint/tendermint/internal/blocksync"
 	"github.com/tendermint/tendermint/internal/consensus"
 	"github.com/tendermint/tendermint/internal/p2p"
 	sm "github.com/tendermint/tendermint/internal/state"
@@ -36,7 +35,7 @@ var (
 				Priority:            5,
 				SendQueueCapacity:   1000,
 				RecvBufferCapacity:  1024,
-				RecvMessageCapacity: blocksync.MaxMsgSize,
+				RecvMessageCapacity: MaxMsgSize,
 				MaxSendBytes:        100,
 			},
 		},
diff --git a/internal/blocksync/v0/reactor_test.go b/internal/blocksync/reactor_test.go
similarity index 99%
rename from internal/blocksync/v0/reactor_test.go
rename to internal/blocksync/reactor_test.go
index 312b1cb397..3824f1460c 100644
--- a/internal/blocksync/v0/reactor_test.go
+++ b/internal/blocksync/reactor_test.go
@@ -1,4 +1,4 @@
-package v0
+package blocksync
 
 import (
 	"os"
diff --git a/node/setup.go b/node/setup.go
index ebaa576c2f..a3491c995c 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -12,7 +12,7 @@ import (
 	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
-	bcv0 "github.com/tendermint/tendermint/internal/blocksync/v0"
+	"github.com/tendermint/tendermint/internal/blocksync"
 	"github.com/tendermint/tendermint/internal/consensus"
 	"github.com/tendermint/tendermint/internal/evidence"
 	"github.com/tendermint/tendermint/internal/mempool"
@@ -310,13 +310,13 @@ func createBlockchainReactor(
 
 	logger = logger.With("module", "blockchain")
 
-	reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", bcv0.ChannelShims)
-	channels := makeChannelsFromShims(router, bcv0.ChannelShims)
+	reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", blocksync.ChannelShims)
+	channels := makeChannelsFromShims(router, blocksync.ChannelShims)
 	peerUpdates := peerManager.Subscribe()
 
-	reactor, err := bcv0.NewReactor(
+	reactor, err := blocksync.NewReactor(
 		logger, state.Copy(), blockExec, blockStore, csReactor,
-		channels[bcv0.BlockSyncChannel], peerUpdates, blockSync,
+		channels[blocksync.BlockSyncChannel], peerUpdates, blockSync,
 		metrics,
 	)
 	if err != nil {
@@ -512,7 +512,7 @@ func makeNodeInfo(
 		txIndexerStatus = "on"
 	}
 
-	bcChannel := byte(bcv0.BlockSyncChannel)
+	bcChannel := byte(blocksync.BlockSyncChannel)
 
 	nodeInfo := types.NodeInfo{
 		ProtocolVersion: types.ProtocolVersion{

From f4a56f4034e04775b4157413c3a5bbf71eef3409 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 15 Oct 2021 11:45:12 -0400
Subject: [PATCH 53/57] p2p: refactor channel description (#7130)

This is another small sliver of #7075, with the intention of removing
the legacy shim layer related to channel registration.
---
 internal/blocksync/reactor.go   |  3 +--
 internal/consensus/reactor.go   | 12 ++++--------
 internal/evidence/reactor.go    |  3 +--
 internal/mempool/v0/reactor.go  |  3 +--
 internal/mempool/v1/reactor.go  |  3 +--
 internal/p2p/conn/connection.go |  6 ++----
 internal/p2p/p2p_test.go        |  1 -
 internal/p2p/p2ptest/network.go |  1 -
 internal/p2p/pex/reactor.go     |  1 -
 internal/p2p/pqueue_test.go     |  2 +-
 internal/p2p/shim.go            |  4 +---
 internal/statesync/reactor.go   | 12 ++++--------
 node/node.go                    |  2 +-
 13 files changed, 17 insertions(+), 36 deletions(-)

diff --git a/internal/blocksync/reactor.go b/internal/blocksync/reactor.go
index 0c193577eb..5f4ce30295 100644
--- a/internal/blocksync/reactor.go
+++ b/internal/blocksync/reactor.go
@@ -29,14 +29,13 @@ var (
 	// ref: https://github.com/tendermint/tendermint/issues/5670
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		BlockSyncChannel: {
-			MsgType: new(bcproto.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(BlockSyncChannel),
+				MessageType:         new(bcproto.Message),
 				Priority:            5,
 				SendQueueCapacity:   1000,
 				RecvBufferCapacity:  1024,
 				RecvMessageCapacity: MaxMsgSize,
-				MaxSendBytes:        100,
 			},
 		},
 	}
diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go
index 22bd7576ea..27ecb46026 100644
--- a/internal/consensus/reactor.go
+++ b/internal/consensus/reactor.go
@@ -31,50 +31,46 @@ var (
 	// ref: https://github.com/tendermint/tendermint/issues/5670
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		StateChannel: {
-			MsgType: new(tmcons.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(StateChannel),
+				MessageType:         new(tmcons.Message),
 				Priority:            8,
 				SendQueueCapacity:   64,
 				RecvMessageCapacity: maxMsgSize,
 				RecvBufferCapacity:  128,
-				MaxSendBytes:        12000,
 			},
 		},
 		DataChannel: {
-			MsgType: new(tmcons.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				// TODO: Consider a split between gossiping current block and catchup
 				// stuff. Once we gossip the whole block there is nothing left to send
 				// until next height or round.
 				ID:                  byte(DataChannel),
+				MessageType:         new(tmcons.Message),
 				Priority:            12,
 				SendQueueCapacity:   64,
 				RecvBufferCapacity:  512,
 				RecvMessageCapacity: maxMsgSize,
-				MaxSendBytes:        40000,
 			},
 		},
 		VoteChannel: {
-			MsgType: new(tmcons.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(VoteChannel),
+				MessageType:         new(tmcons.Message),
 				Priority:            10,
 				SendQueueCapacity:   64,
 				RecvBufferCapacity:  128,
 				RecvMessageCapacity: maxMsgSize,
-				MaxSendBytes:        150,
 			},
 		},
 		VoteSetBitsChannel: {
-			MsgType: new(tmcons.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(VoteSetBitsChannel),
+				MessageType:         new(tmcons.Message),
 				Priority:            5,
 				SendQueueCapacity:   8,
 				RecvBufferCapacity:  128,
 				RecvMessageCapacity: maxMsgSize,
-				MaxSendBytes:        50,
 			},
 		},
 	}
diff --git a/internal/evidence/reactor.go b/internal/evidence/reactor.go
index a454038fdc..0090bd32f7 100644
--- a/internal/evidence/reactor.go
+++ b/internal/evidence/reactor.go
@@ -27,13 +27,12 @@ var (
 	// ref: https://github.com/tendermint/tendermint/issues/5670
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		EvidenceChannel: {
-			MsgType: new(tmproto.EvidenceList),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(EvidenceChannel),
+				MessageType:         new(tmproto.EvidenceList),
 				Priority:            6,
 				RecvMessageCapacity: maxMsgSize,
 				RecvBufferCapacity:  32,
-				MaxSendBytes:        400,
 			},
 		},
 	}
diff --git a/internal/mempool/v0/reactor.go b/internal/mempool/v0/reactor.go
index 86392e96fd..1587c07788 100644
--- a/internal/mempool/v0/reactor.go
+++ b/internal/mempool/v0/reactor.go
@@ -100,13 +100,12 @@ func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe
 
 	return map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		mempool.MempoolChannel: {
-			MsgType: new(protomem.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(mempool.MempoolChannel),
+				MessageType:         new(protomem.Message),
 				Priority:            5,
 				RecvMessageCapacity: batchMsg.Size(),
 				RecvBufferCapacity:  128,
-				MaxSendBytes:        5000,
 			},
 		},
 	}
diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go
index f078083871..e31977cc9e 100644
--- a/internal/mempool/v1/reactor.go
+++ b/internal/mempool/v1/reactor.go
@@ -107,13 +107,12 @@ func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe
 
 	return map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		mempool.MempoolChannel: {
-			MsgType: new(protomem.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(mempool.MempoolChannel),
+				MessageType:         new(protomem.Message),
 				Priority:            5,
 				RecvMessageCapacity: batchMsg.Size(),
 				RecvBufferCapacity:  128,
-				MaxSendBytes:        5000,
 			},
 		},
 	}
diff --git a/internal/p2p/conn/connection.go b/internal/p2p/conn/connection.go
index 0ab7b7546b..c6a9b206c5 100644
--- a/internal/p2p/conn/connection.go
+++ b/internal/p2p/conn/connection.go
@@ -612,6 +612,8 @@ type ChannelDescriptor struct {
 	ID       byte
 	Priority int
 
+	MessageType proto.Message
+
 	// TODO: Remove once p2p refactor is complete.
 	SendQueueCapacity   int
 	RecvMessageCapacity int
@@ -619,10 +621,6 @@ type ChannelDescriptor struct {
 	// RecvBufferCapacity defines the max buffer size of inbound messages for a
 	// given p2p Channel queue.
 	RecvBufferCapacity int
-
-	// MaxSendBytes defines the maximum number of bytes that can be sent at any
-	// given moment from a Channel to a peer.
-	MaxSendBytes uint
 }
 
 func (chDesc ChannelDescriptor) FillDefaults() (filled ChannelDescriptor) {
diff --git a/internal/p2p/p2p_test.go b/internal/p2p/p2p_test.go
index 6e524d492a..91e1c08247 100644
--- a/internal/p2p/p2p_test.go
+++ b/internal/p2p/p2p_test.go
@@ -19,7 +19,6 @@ var (
 		Priority:            5,
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: 10,
-		MaxSendBytes:        1000,
 	}
 
 	selfKey  crypto.PrivKey = ed25519.GenPrivKeyFromSecret([]byte{0xf9, 0x1b, 0x08, 0xaa, 0x38, 0xee, 0x34, 0xdd})
diff --git a/internal/p2p/p2ptest/network.go b/internal/p2p/p2ptest/network.go
index 1daba3f147..21aa1a0ea5 100644
--- a/internal/p2p/p2ptest/network.go
+++ b/internal/p2p/p2ptest/network.go
@@ -339,6 +339,5 @@ func MakeChannelDesc(chID p2p.ChannelID) p2p.ChannelDescriptor {
 		Priority:            5,
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: 10,
-		MaxSendBytes:        1000,
 	}
 }
diff --git a/internal/p2p/pex/reactor.go b/internal/p2p/pex/reactor.go
index f5c03adf8e..f313279c30 100644
--- a/internal/p2p/pex/reactor.go
+++ b/internal/p2p/pex/reactor.go
@@ -69,7 +69,6 @@ func ChannelDescriptor() conn.ChannelDescriptor {
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: maxMsgSize,
 		RecvBufferCapacity:  32,
-		MaxSendBytes:        200,
 	}
 }
 
diff --git a/internal/p2p/pqueue_test.go b/internal/p2p/pqueue_test.go
index c038408ef7..18f0c02e36 100644
--- a/internal/p2p/pqueue_test.go
+++ b/internal/p2p/pqueue_test.go
@@ -13,7 +13,7 @@ type testMessage = gogotypes.StringValue
 func TestCloseWhileDequeueFull(t *testing.T) {
 	enqueueLength := 5
 	chDescs := []ChannelDescriptor{
-		{ID: 0x01, Priority: 1, MaxSendBytes: 4},
+		{ID: 0x01, Priority: 1},
 	}
 	pqueue := newPQScheduler(log.NewNopLogger(), NopMetrics(), chDescs, uint(enqueueLength), 1, 120)
 
diff --git a/internal/p2p/shim.go b/internal/p2p/shim.go
index 9f82bc11aa..f57ce18b99 100644
--- a/internal/p2p/shim.go
+++ b/internal/p2p/shim.go
@@ -3,7 +3,6 @@ package p2p
 import (
 	"sort"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/tendermint/tendermint/libs/log"
 )
 
@@ -12,7 +11,6 @@ import (
 // A ChannelDescriptorShim is not contained in ReactorShim, but is rather
 // used to construct a ReactorShim.
 type ChannelDescriptorShim struct {
-	MsgType    proto.Message
 	Descriptor *ChannelDescriptor
 }
 
@@ -61,7 +59,7 @@ func NewChannelShim(cds *ChannelDescriptorShim, buf uint) *ChannelShim {
 		Descriptor: cds.Descriptor,
 		Channel: NewChannel(
 			ChannelID(cds.Descriptor.ID),
-			cds.MsgType,
+			cds.Descriptor.MessageType,
 			inCh,
 			outCh,
 			errCh,
diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index 74803b3e2b..3757d028d9 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -38,47 +38,43 @@ var (
 	// ref: https://github.com/tendermint/tendermint/issues/5670
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		SnapshotChannel: {
-			MsgType: new(ssproto.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(SnapshotChannel),
+				MessageType:         new(ssproto.Message),
 				Priority:            6,
 				SendQueueCapacity:   10,
 				RecvMessageCapacity: snapshotMsgSize,
 				RecvBufferCapacity:  128,
-				MaxSendBytes:        400,
 			},
 		},
 		ChunkChannel: {
-			MsgType: new(ssproto.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(ChunkChannel),
 				Priority:            3,
+				MessageType:         new(ssproto.Message),
 				SendQueueCapacity:   4,
 				RecvMessageCapacity: chunkMsgSize,
 				RecvBufferCapacity:  128,
-				MaxSendBytes:        400,
 			},
 		},
 		LightBlockChannel: {
-			MsgType: new(ssproto.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(LightBlockChannel),
+				MessageType:         new(ssproto.Message),
 				Priority:            5,
 				SendQueueCapacity:   10,
 				RecvMessageCapacity: lightBlockMsgSize,
 				RecvBufferCapacity:  128,
-				MaxSendBytes:        400,
 			},
 		},
 		ParamsChannel: {
-			MsgType: new(ssproto.Message),
 			Descriptor: &p2p.ChannelDescriptor{
 				ID:                  byte(ParamsChannel),
+				MessageType:         new(ssproto.Message),
 				Priority:            2,
 				SendQueueCapacity:   10,
 				RecvMessageCapacity: paramMsgSize,
 				RecvBufferCapacity:  128,
-				MaxSendBytes:        400,
 			},
 		},
 	}
diff --git a/node/node.go b/node/node.go
index b6c47a9ce8..6a66f42244 100644
--- a/node/node.go
+++ b/node/node.go
@@ -1119,7 +1119,7 @@ func makeChannelsFromShims(
 
 	channels := map[p2p.ChannelID]*p2p.Channel{}
 	for chID, chShim := range chShims {
-		ch, err := router.OpenChannel(*chShim.Descriptor, chShim.MsgType, chShim.Descriptor.RecvBufferCapacity)
+		ch, err := router.OpenChannel(*chShim.Descriptor, chShim.Descriptor.MessageType, chShim.Descriptor.RecvBufferCapacity)
 		if err != nil {
 			panic(fmt.Sprintf("failed to open channel %v: %v", chID, err))
 		}

From 0900ea8396359cdf72be555cddcf597349e39af1 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 15 Oct 2021 12:31:33 -0400
Subject: [PATCH 54/57] p2p: channel shim cleanup (#7129)

---
 internal/blocksync/reactor.go        |  2 +-
 internal/blocksync/reactor_test.go   |  2 +-
 internal/consensus/reactor.go        |  8 +--
 internal/consensus/reactor_test.go   |  2 +-
 internal/evidence/reactor.go         |  2 +-
 internal/evidence/reactor_test.go    |  2 +-
 internal/mempool/v0/reactor.go       |  2 +-
 internal/mempool/v0/reactor_test.go  |  2 +-
 internal/mempool/v1/reactor.go       |  2 +-
 internal/mempool/v1/reactor_test.go  |  2 +-
 internal/p2p/conn/connection.go      | 14 +++--
 internal/p2p/conn/connection_test.go | 22 +++----
 internal/p2p/mocks/connection.go     | 17 +++---
 internal/p2p/mocks/transport.go      |  8 +++
 internal/p2p/p2p_test.go             |  2 +-
 internal/p2p/p2ptest/network.go      |  4 +-
 internal/p2p/pex/reactor.go          |  2 +-
 internal/p2p/pqueue.go               |  2 +-
 internal/p2p/router.go               |  9 +--
 internal/p2p/router_test.go          |  7 ++-
 internal/p2p/shim.go                 | 91 ----------------------------
 internal/p2p/transport.go            |  4 ++
 internal/p2p/transport_mconn.go      |  6 +-
 internal/p2p/transport_mconn_test.go |  8 +--
 internal/p2p/transport_memory.go     |  2 +
 internal/p2p/types.go                |  1 +
 internal/statesync/reactor.go        |  8 +--
 node/node.go                         | 30 ++-------
 node/setup.go                        | 31 ++++------
 29 files changed, 99 insertions(+), 195 deletions(-)

diff --git a/internal/blocksync/reactor.go b/internal/blocksync/reactor.go
index 5f4ce30295..86aaf79d3a 100644
--- a/internal/blocksync/reactor.go
+++ b/internal/blocksync/reactor.go
@@ -30,7 +30,7 @@ var (
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		BlockSyncChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(BlockSyncChannel),
+				ID:                  BlockSyncChannel,
 				MessageType:         new(bcproto.Message),
 				Priority:            5,
 				SendQueueCapacity:   1000,
diff --git a/internal/blocksync/reactor_test.go b/internal/blocksync/reactor_test.go
index 3824f1460c..59889eec49 100644
--- a/internal/blocksync/reactor_test.go
+++ b/internal/blocksync/reactor_test.go
@@ -65,7 +65,7 @@ func setup(
 		blockSync:         true,
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: byte(BlockSyncChannel)}
+	chDesc := p2p.ChannelDescriptor{ID: BlockSyncChannel}
 	rts.blockSyncChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(bcproto.Message), int(chBuf))
 
 	i := 0
diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go
index 27ecb46026..dde36306cd 100644
--- a/internal/consensus/reactor.go
+++ b/internal/consensus/reactor.go
@@ -32,7 +32,7 @@ var (
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		StateChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(StateChannel),
+				ID:                  StateChannel,
 				MessageType:         new(tmcons.Message),
 				Priority:            8,
 				SendQueueCapacity:   64,
@@ -45,7 +45,7 @@ var (
 				// TODO: Consider a split between gossiping current block and catchup
 				// stuff. Once we gossip the whole block there is nothing left to send
 				// until next height or round.
-				ID:                  byte(DataChannel),
+				ID:                  DataChannel,
 				MessageType:         new(tmcons.Message),
 				Priority:            12,
 				SendQueueCapacity:   64,
@@ -55,7 +55,7 @@ var (
 		},
 		VoteChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(VoteChannel),
+				ID:                  VoteChannel,
 				MessageType:         new(tmcons.Message),
 				Priority:            10,
 				SendQueueCapacity:   64,
@@ -65,7 +65,7 @@ var (
 		},
 		VoteSetBitsChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(VoteSetBitsChannel),
+				ID:                  VoteSetBitsChannel,
 				MessageType:         new(tmcons.Message),
 				Priority:            5,
 				SendQueueCapacity:   8,
diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go
index e536906a98..04bc3708ee 100644
--- a/internal/consensus/reactor_test.go
+++ b/internal/consensus/reactor_test.go
@@ -52,7 +52,7 @@ type reactorTestSuite struct {
 
 func chDesc(chID p2p.ChannelID) p2p.ChannelDescriptor {
 	return p2p.ChannelDescriptor{
-		ID: byte(chID),
+		ID: chID,
 	}
 }
 
diff --git a/internal/evidence/reactor.go b/internal/evidence/reactor.go
index 0090bd32f7..0cf261441a 100644
--- a/internal/evidence/reactor.go
+++ b/internal/evidence/reactor.go
@@ -28,7 +28,7 @@ var (
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		EvidenceChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(EvidenceChannel),
+				ID:                  EvidenceChannel,
 				MessageType:         new(tmproto.EvidenceList),
 				Priority:            6,
 				RecvMessageCapacity: maxMsgSize,
diff --git a/internal/evidence/reactor_test.go b/internal/evidence/reactor_test.go
index b8055263da..7963ba959c 100644
--- a/internal/evidence/reactor_test.go
+++ b/internal/evidence/reactor_test.go
@@ -62,7 +62,7 @@ func setup(t *testing.T, stateStores []sm.Store, chBuf uint) *reactorTestSuite {
 		peerChans:      make(map[types.NodeID]chan p2p.PeerUpdate, numStateStores),
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: byte(evidence.EvidenceChannel)}
+	chDesc := p2p.ChannelDescriptor{ID: evidence.EvidenceChannel}
 	rts.evidenceChannels = rts.network.MakeChannelsNoCleanup(t,
 		chDesc,
 		new(tmproto.EvidenceList),
diff --git a/internal/mempool/v0/reactor.go b/internal/mempool/v0/reactor.go
index 1587c07788..010f98f5db 100644
--- a/internal/mempool/v0/reactor.go
+++ b/internal/mempool/v0/reactor.go
@@ -101,7 +101,7 @@ func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe
 	return map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		mempool.MempoolChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(mempool.MempoolChannel),
+				ID:                  mempool.MempoolChannel,
 				MessageType:         new(protomem.Message),
 				Priority:            5,
 				RecvMessageCapacity: batchMsg.Size(),
diff --git a/internal/mempool/v0/reactor_test.go b/internal/mempool/v0/reactor_test.go
index b0462a2496..4ae2523a14 100644
--- a/internal/mempool/v0/reactor_test.go
+++ b/internal/mempool/v0/reactor_test.go
@@ -50,7 +50,7 @@ func setup(t *testing.T, config *config.MempoolConfig, numNodes int, chBuf uint)
 		peerUpdates:    make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: byte(mempool.MempoolChannel)}
+	chDesc := p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
 	rts.mempoolChnnels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(protomem.Message), int(chBuf))
 
 	for nodeID := range rts.network.Nodes {
diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go
index e31977cc9e..72154b4a88 100644
--- a/internal/mempool/v1/reactor.go
+++ b/internal/mempool/v1/reactor.go
@@ -108,7 +108,7 @@ func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe
 	return map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		mempool.MempoolChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(mempool.MempoolChannel),
+				ID:                  mempool.MempoolChannel,
 				MessageType:         new(protomem.Message),
 				Priority:            5,
 				RecvMessageCapacity: batchMsg.Size(),
diff --git a/internal/mempool/v1/reactor_test.go b/internal/mempool/v1/reactor_test.go
index 5934d534c3..1449b20b1b 100644
--- a/internal/mempool/v1/reactor_test.go
+++ b/internal/mempool/v1/reactor_test.go
@@ -52,7 +52,7 @@ func setupReactors(t *testing.T, numNodes int, chBuf uint) *reactorTestSuite {
 		peerUpdates:     make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: byte(mempool.MempoolChannel)}
+	chDesc := p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
 	rts.mempoolChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(protomem.Message), int(chBuf))
 
 	for nodeID := range rts.network.Nodes {
diff --git a/internal/p2p/conn/connection.go b/internal/p2p/conn/connection.go
index c6a9b206c5..1e149a2e53 100644
--- a/internal/p2p/conn/connection.go
+++ b/internal/p2p/conn/connection.go
@@ -48,7 +48,7 @@ const (
 	defaultPongTimeout         = 45 * time.Second
 )
 
-type receiveCbFunc func(chID byte, msgBytes []byte)
+type receiveCbFunc func(chID ChannelID, msgBytes []byte)
 type errorCbFunc func(interface{})
 
 /*
@@ -82,7 +82,7 @@ type MConnection struct {
 	send          chan struct{}
 	pong          chan struct{}
 	channels      []*Channel
-	channelsIdx   map[byte]*Channel
+	channelsIdx   map[ChannelID]*Channel
 	onReceive     receiveCbFunc
 	onError       errorCbFunc
 	errored       uint32
@@ -186,7 +186,7 @@ func NewMConnectionWithConfig(
 	}
 
 	// Create channels
-	var channelsIdx = map[byte]*Channel{}
+	var channelsIdx = map[ChannelID]*Channel{}
 	var channels = []*Channel{}
 
 	for _, desc := range chDescs {
@@ -307,7 +307,7 @@ func (c *MConnection) stopForError(r interface{}) {
 }
 
 // Queues a message to be sent to channel.
-func (c *MConnection) Send(chID byte, msgBytes []byte) bool {
+func (c *MConnection) Send(chID ChannelID, msgBytes []byte) bool {
 	if !c.IsRunning() {
 		return false
 	}
@@ -540,7 +540,7 @@ FOR_LOOP:
 				// never block
 			}
 		case *tmp2p.Packet_PacketMsg:
-			channelID := byte(pkt.PacketMsg.ChannelID)
+			channelID := ChannelID(pkt.PacketMsg.ChannelID)
 			channel, ok := c.channelsIdx[channelID]
 			if pkt.PacketMsg.ChannelID < 0 || pkt.PacketMsg.ChannelID > math.MaxUint8 || !ok || channel == nil {
 				err := fmt.Errorf("unknown channel %X", pkt.PacketMsg.ChannelID)
@@ -607,9 +607,11 @@ type ChannelStatus struct {
 }
 
 //-----------------------------------------------------------------------------
+// ChannelID is an arbitrary channel ID.
+type ChannelID uint16
 
 type ChannelDescriptor struct {
-	ID       byte
+	ID       ChannelID
 	Priority int
 
 	MessageType proto.Message
diff --git a/internal/p2p/conn/connection_test.go b/internal/p2p/conn/connection_test.go
index 6a9c0988f5..1ed179ad86 100644
--- a/internal/p2p/conn/connection_test.go
+++ b/internal/p2p/conn/connection_test.go
@@ -20,7 +20,7 @@ import (
 const maxPingPongPacketSize = 1024 // bytes
 
 func createTestMConnection(conn net.Conn) *MConnection {
-	onReceive := func(chID byte, msgBytes []byte) {
+	onReceive := func(chID ChannelID, msgBytes []byte) {
 	}
 	onError := func(r interface{}) {
 	}
@@ -31,7 +31,7 @@ func createTestMConnection(conn net.Conn) *MConnection {
 
 func createMConnectionWithCallbacks(
 	conn net.Conn,
-	onReceive func(chID byte, msgBytes []byte),
+	onReceive func(chID ChannelID, msgBytes []byte),
 	onError func(r interface{}),
 ) *MConnection {
 	cfg := DefaultMConnConfig()
@@ -111,7 +111,7 @@ func TestMConnectionReceive(t *testing.T) {
 
 	receivedCh := make(chan []byte)
 	errorsCh := make(chan interface{})
-	onReceive := func(chID byte, msgBytes []byte) {
+	onReceive := func(chID ChannelID, msgBytes []byte) {
 		receivedCh <- msgBytes
 	}
 	onError := func(r interface{}) {
@@ -146,7 +146,7 @@ func TestMConnectionPongTimeoutResultsInError(t *testing.T) {
 
 	receivedCh := make(chan []byte)
 	errorsCh := make(chan interface{})
-	onReceive := func(chID byte, msgBytes []byte) {
+	onReceive := func(chID ChannelID, msgBytes []byte) {
 		receivedCh <- msgBytes
 	}
 	onError := func(r interface{}) {
@@ -184,7 +184,7 @@ func TestMConnectionMultiplePongsInTheBeginning(t *testing.T) {
 
 	receivedCh := make(chan []byte)
 	errorsCh := make(chan interface{})
-	onReceive := func(chID byte, msgBytes []byte) {
+	onReceive := func(chID ChannelID, msgBytes []byte) {
 		receivedCh <- msgBytes
 	}
 	onError := func(r interface{}) {
@@ -238,7 +238,7 @@ func TestMConnectionMultiplePings(t *testing.T) {
 
 	receivedCh := make(chan []byte)
 	errorsCh := make(chan interface{})
-	onReceive := func(chID byte, msgBytes []byte) {
+	onReceive := func(chID ChannelID, msgBytes []byte) {
 		receivedCh <- msgBytes
 	}
 	onError := func(r interface{}) {
@@ -285,7 +285,7 @@ func TestMConnectionPingPongs(t *testing.T) {
 
 	receivedCh := make(chan []byte)
 	errorsCh := make(chan interface{})
-	onReceive := func(chID byte, msgBytes []byte) {
+	onReceive := func(chID ChannelID, msgBytes []byte) {
 		receivedCh <- msgBytes
 	}
 	onError := func(r interface{}) {
@@ -342,7 +342,7 @@ func TestMConnectionStopsAndReturnsError(t *testing.T) {
 
 	receivedCh := make(chan []byte)
 	errorsCh := make(chan interface{})
-	onReceive := func(chID byte, msgBytes []byte) {
+	onReceive := func(chID ChannelID, msgBytes []byte) {
 		receivedCh <- msgBytes
 	}
 	onError := func(r interface{}) {
@@ -371,7 +371,7 @@ func TestMConnectionStopsAndReturnsError(t *testing.T) {
 func newClientAndServerConnsForReadErrors(t *testing.T, chOnErr chan struct{}) (*MConnection, *MConnection) {
 	server, client := NetPipe()
 
-	onReceive := func(chID byte, msgBytes []byte) {}
+	onReceive := func(chID ChannelID, msgBytes []byte) {}
 	onError := func(r interface{}) {}
 
 	// create client conn with two channels
@@ -443,7 +443,7 @@ func TestMConnectionReadErrorLongMessage(t *testing.T) {
 	mconnClient, mconnServer := newClientAndServerConnsForReadErrors(t, chOnErr)
 	t.Cleanup(stopAll(t, mconnClient, mconnServer))
 
-	mconnServer.onReceive = func(chID byte, msgBytes []byte) {
+	mconnServer.onReceive = func(chID ChannelID, msgBytes []byte) {
 		chOnRcv <- struct{}{}
 	}
 
@@ -538,7 +538,7 @@ func TestMConnectionChannelOverflow(t *testing.T) {
 	mconnClient, mconnServer := newClientAndServerConnsForReadErrors(t, chOnErr)
 	t.Cleanup(stopAll(t, mconnClient, mconnServer))
 
-	mconnServer.onReceive = func(chID byte, msgBytes []byte) {
+	mconnServer.onReceive = func(chID ChannelID, msgBytes []byte) {
 		chOnRcv <- struct{}{}
 	}
 
diff --git a/internal/p2p/mocks/connection.go b/internal/p2p/mocks/connection.go
index 03f7b5b335..65b9afafb6 100644
--- a/internal/p2p/mocks/connection.go
+++ b/internal/p2p/mocks/connection.go
@@ -5,9 +5,12 @@ package mocks
 import (
 	context "context"
 
-	mock "github.com/stretchr/testify/mock"
+	conn "github.com/tendermint/tendermint/internal/p2p/conn"
+
 	crypto "github.com/tendermint/tendermint/crypto"
 
+	mock "github.com/stretchr/testify/mock"
+
 	p2p "github.com/tendermint/tendermint/internal/p2p"
 
 	types "github.com/tendermint/tendermint/types"
@@ -77,14 +80,14 @@ func (_m *Connection) LocalEndpoint() p2p.Endpoint {
 }
 
 // ReceiveMessage provides a mock function with given fields:
-func (_m *Connection) ReceiveMessage() (p2p.ChannelID, []byte, error) {
+func (_m *Connection) ReceiveMessage() (conn.ChannelID, []byte, error) {
 	ret := _m.Called()
 
-	var r0 p2p.ChannelID
-	if rf, ok := ret.Get(0).(func() p2p.ChannelID); ok {
+	var r0 conn.ChannelID
+	if rf, ok := ret.Get(0).(func() conn.ChannelID); ok {
 		r0 = rf()
 	} else {
-		r0 = ret.Get(0).(p2p.ChannelID)
+		r0 = ret.Get(0).(conn.ChannelID)
 	}
 
 	var r1 []byte
@@ -121,11 +124,11 @@ func (_m *Connection) RemoteEndpoint() p2p.Endpoint {
 }
 
 // SendMessage provides a mock function with given fields: _a0, _a1
-func (_m *Connection) SendMessage(_a0 p2p.ChannelID, _a1 []byte) error {
+func (_m *Connection) SendMessage(_a0 conn.ChannelID, _a1 []byte) error {
 	ret := _m.Called(_a0, _a1)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(p2p.ChannelID, []byte) error); ok {
+	if rf, ok := ret.Get(0).(func(conn.ChannelID, []byte) error); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		r0 = ret.Error(0)
diff --git a/internal/p2p/mocks/transport.go b/internal/p2p/mocks/transport.go
index 82bd670cbd..2fc7baa29e 100644
--- a/internal/p2p/mocks/transport.go
+++ b/internal/p2p/mocks/transport.go
@@ -5,7 +5,10 @@ package mocks
 import (
 	context "context"
 
+	conn "github.com/tendermint/tendermint/internal/p2p/conn"
+
 	mock "github.com/stretchr/testify/mock"
+
 	p2p "github.com/tendermint/tendermint/internal/p2p"
 )
 
@@ -37,6 +40,11 @@ func (_m *Transport) Accept() (p2p.Connection, error) {
 	return r0, r1
 }
 
+// AddChannelDescriptors provides a mock function with given fields: _a0
+func (_m *Transport) AddChannelDescriptors(_a0 []*conn.ChannelDescriptor) {
+	_m.Called(_a0)
+}
+
 // Close provides a mock function with given fields:
 func (_m *Transport) Close() error {
 	ret := _m.Called()
diff --git a/internal/p2p/p2p_test.go b/internal/p2p/p2p_test.go
index 91e1c08247..f5ed5706c5 100644
--- a/internal/p2p/p2p_test.go
+++ b/internal/p2p/p2p_test.go
@@ -15,7 +15,7 @@ var (
 	ctx    = context.Background()
 	chID   = p2p.ChannelID(1)
 	chDesc = p2p.ChannelDescriptor{
-		ID:                  byte(chID),
+		ID:                  chID,
 		Priority:            5,
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: 10,
diff --git a/internal/p2p/p2ptest/network.go b/internal/p2p/p2ptest/network.go
index 21aa1a0ea5..2ed8887643 100644
--- a/internal/p2p/p2ptest/network.go
+++ b/internal/p2p/p2ptest/network.go
@@ -285,7 +285,7 @@ func (n *Node) MakeChannel(t *testing.T, chDesc p2p.ChannelDescriptor,
 	messageType proto.Message, size int) *p2p.Channel {
 	channel, err := n.Router.OpenChannel(chDesc, messageType, size)
 	require.NoError(t, err)
-	require.Contains(t, n.Router.NodeInfo().Channels, chDesc.ID)
+	require.Contains(t, n.Router.NodeInfo().Channels, byte(chDesc.ID))
 	t.Cleanup(func() {
 		RequireEmpty(t, channel)
 		channel.Close()
@@ -335,7 +335,7 @@ func (n *Node) MakePeerUpdatesNoRequireEmpty(t *testing.T) *p2p.PeerUpdates {
 
 func MakeChannelDesc(chID p2p.ChannelID) p2p.ChannelDescriptor {
 	return p2p.ChannelDescriptor{
-		ID:                  byte(chID),
+		ID:                  chID,
 		Priority:            5,
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: 10,
diff --git a/internal/p2p/pex/reactor.go b/internal/p2p/pex/reactor.go
index f313279c30..d43d836ce8 100644
--- a/internal/p2p/pex/reactor.go
+++ b/internal/p2p/pex/reactor.go
@@ -25,7 +25,7 @@ var (
 // See https://github.com/tendermint/tendermint/issues/6371
 const (
 	// PexChannel is a channel for PEX messages
-	PexChannel = byte(0x00)
+	PexChannel = 0x00
 
 	// over-estimate of max NetAddress size
 	// hexID (40) + IP (16) + Port (2) + Name (100) ...
diff --git a/internal/p2p/pqueue.go b/internal/p2p/pqueue.go
index b19436e15a..fd0a43db68 100644
--- a/internal/p2p/pqueue.go
+++ b/internal/p2p/pqueue.go
@@ -99,7 +99,7 @@ func newPQScheduler(
 	)
 
 	for _, chDesc := range chDescsCopy {
-		chID := ChannelID(chDesc.ID)
+		chID := chDesc.ID
 		chPriorities[chID] = uint(chDesc.Priority)
 		sizes[uint(chDesc.Priority)] = 0
 	}
diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index f7d012b493..11d0514bba 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -23,9 +23,6 @@ const queueBufferDefault = 32
 
 const dialRandomizerIntervalMillisecond = 3000
 
-// ChannelID is an arbitrary channel ID.
-type ChannelID uint16
-
 // Envelope contains a message with sender/receiver routing info.
 type Envelope struct {
 	From      types.NodeID  // sender (empty if outbound)
@@ -361,7 +358,7 @@ func (r *Router) OpenChannel(chDesc ChannelDescriptor, messageType proto.Message
 	r.channelMtx.Lock()
 	defer r.channelMtx.Unlock()
 
-	id := ChannelID(chDesc.ID)
+	id := chDesc.ID
 	if _, ok := r.channelQueues[id]; ok {
 		return nil, fmt.Errorf("channel %v already exists", id)
 	}
@@ -383,6 +380,10 @@ func (r *Router) OpenChannel(chDesc ChannelDescriptor, messageType proto.Message
 	// add the channel to the nodeInfo if it's not already there.
 	r.nodeInfo.AddChannel(uint16(chDesc.ID))
 
+	for _, t := range r.transports {
+		t.AddChannelDescriptors([]*ChannelDescriptor{&chDesc})
+	}
+
 	go func() {
 		defer func() {
 			r.channelMtx.Lock()
diff --git a/internal/p2p/router_test.go b/internal/p2p/router_test.go
index c12f1a2f09..7f922c29d7 100644
--- a/internal/p2p/router_test.go
+++ b/internal/p2p/router_test.go
@@ -121,17 +121,17 @@ func TestRouter_Channel_Basic(t *testing.T) {
 	// Opening a channel should work.
 	channel, err := router.OpenChannel(chDesc, &p2ptest.Message{}, 0)
 	require.NoError(t, err)
-	require.Contains(t, router.NodeInfo().Channels, chDesc.ID)
+	require.Contains(t, router.NodeInfo().Channels, byte(chDesc.ID))
 
 	// Opening the same channel again should fail.
 	_, err = router.OpenChannel(chDesc, &p2ptest.Message{}, 0)
 	require.Error(t, err)
 
 	// Opening a different channel should work.
-	chDesc2 := p2p.ChannelDescriptor{ID: byte(2)}
+	chDesc2 := p2p.ChannelDescriptor{ID: 2}
 	_, err = router.OpenChannel(chDesc2, &p2ptest.Message{}, 0)
 	require.NoError(t, err)
-	require.Contains(t, router.NodeInfo().Channels, chDesc2.ID)
+	require.Contains(t, router.NodeInfo().Channels, byte(chDesc2.ID))
 
 	// Closing the channel, then opening it again should be fine.
 	channel.Close()
@@ -865,6 +865,7 @@ func TestRouter_DontSendOnInvalidChannel(t *testing.T) {
 	mockConnection.On("ReceiveMessage").Return(chID, nil, io.EOF)
 
 	mockTransport := &mocks.Transport{}
+	mockTransport.On("AddChannelDescriptors", mock.Anything).Return()
 	mockTransport.On("String").Maybe().Return("mock")
 	mockTransport.On("Protocols").Return([]p2p.Protocol{"mock"})
 	mockTransport.On("Close").Return(nil)
diff --git a/internal/p2p/shim.go b/internal/p2p/shim.go
index f57ce18b99..8de0b71c71 100644
--- a/internal/p2p/shim.go
+++ b/internal/p2p/shim.go
@@ -1,11 +1,5 @@
 package p2p
 
-import (
-	"sort"
-
-	"github.com/tendermint/tendermint/libs/log"
-)
-
 // ChannelDescriptorShim defines a shim wrapper around a legacy p2p channel
 // and the proto.Message the new p2p Channel is responsible for handling.
 // A ChannelDescriptorShim is not contained in ReactorShim, but is rather
@@ -13,88 +7,3 @@ import (
 type ChannelDescriptorShim struct {
 	Descriptor *ChannelDescriptor
 }
-
-// ChannelShim defines a generic shim wrapper around a legacy p2p channel
-// and the new p2p Channel. It also includes the raw bi-directional Go channels
-// so we can proxy message delivery.
-type ChannelShim struct {
-	Descriptor *ChannelDescriptor
-	Channel    *Channel
-	inCh       chan<- Envelope
-	outCh      <-chan Envelope
-	errCh      <-chan PeerError
-}
-
-// ReactorShim defines a generic shim wrapper around a BaseReactor. It is
-// responsible for wiring up legacy p2p behavior to the new p2p semantics
-// (e.g. proxying Envelope messages to legacy peers).
-type ReactorShim struct {
-	Name        string
-	PeerUpdates *PeerUpdates
-	Channels    map[ChannelID]*ChannelShim
-}
-
-func NewReactorShim(logger log.Logger, name string, descriptors map[ChannelID]*ChannelDescriptorShim) *ReactorShim {
-	channels := make(map[ChannelID]*ChannelShim)
-
-	for _, cds := range descriptors {
-		chShim := NewChannelShim(cds, 0)
-		channels[chShim.Channel.ID] = chShim
-	}
-
-	rs := &ReactorShim{
-		Name:        name,
-		PeerUpdates: NewPeerUpdates(make(chan PeerUpdate), 0),
-		Channels:    channels,
-	}
-
-	return rs
-}
-
-func NewChannelShim(cds *ChannelDescriptorShim, buf uint) *ChannelShim {
-	inCh := make(chan Envelope, buf)
-	outCh := make(chan Envelope, buf)
-	errCh := make(chan PeerError, buf)
-	return &ChannelShim{
-		Descriptor: cds.Descriptor,
-		Channel: NewChannel(
-			ChannelID(cds.Descriptor.ID),
-			cds.Descriptor.MessageType,
-			inCh,
-			outCh,
-			errCh,
-		),
-		inCh:  inCh,
-		outCh: outCh,
-		errCh: errCh,
-	}
-}
-
-// GetChannels implements the legacy Reactor interface for getting a slice of all
-// the supported ChannelDescriptors.
-func (rs *ReactorShim) GetChannels() []*ChannelDescriptor {
-	sortedChIDs := make([]ChannelID, 0, len(rs.Channels))
-	for cID := range rs.Channels {
-		sortedChIDs = append(sortedChIDs, cID)
-	}
-
-	sort.Slice(sortedChIDs, func(i, j int) bool { return sortedChIDs[i] < sortedChIDs[j] })
-
-	descriptors := make([]*ChannelDescriptor, len(rs.Channels))
-	for i, cID := range sortedChIDs {
-		descriptors[i] = rs.Channels[cID].Descriptor
-	}
-
-	return descriptors
-}
-
-// GetChannel returns a p2p Channel reference for a given ChannelID. If no
-// Channel exists, nil is returned.
-func (rs *ReactorShim) GetChannel(cID ChannelID) *Channel {
-	channelShim, ok := rs.Channels[cID]
-	if ok {
-		return channelShim.Channel
-	}
-
-	return nil
-}
diff --git a/internal/p2p/transport.go b/internal/p2p/transport.go
index b49b096bbe..e78906362c 100644
--- a/internal/p2p/transport.go
+++ b/internal/p2p/transport.go
@@ -44,6 +44,10 @@ type Transport interface {
 	// Close stops accepting new connections, but does not close active connections.
 	Close() error
 
+	// AddChannelDescriptors is only part of this interface
+	// temporarily
+	AddChannelDescriptors([]*ChannelDescriptor)
+
 	// Stringer is used to display the transport, e.g. in logs.
 	//
 	// Without this, the logger may use reflection to access and display
diff --git a/internal/p2p/transport_mconn.go b/internal/p2p/transport_mconn.go
index de643bdb96..3e0281c39d 100644
--- a/internal/p2p/transport_mconn.go
+++ b/internal/p2p/transport_mconn.go
@@ -348,9 +348,9 @@ func (c *mConnConnection) handshake(
 }
 
 // onReceive is a callback for MConnection received messages.
-func (c *mConnConnection) onReceive(chID byte, payload []byte) {
+func (c *mConnConnection) onReceive(chID ChannelID, payload []byte) {
 	select {
-	case c.receiveCh <- mConnMessage{channelID: ChannelID(chID), payload: payload}:
+	case c.receiveCh <- mConnMessage{channelID: chID, payload: payload}:
 	case <-c.closeCh:
 	}
 }
@@ -387,7 +387,7 @@ func (c *mConnConnection) SendMessage(chID ChannelID, msg []byte) error {
 	case <-c.closeCh:
 		return io.EOF
 	default:
-		if ok := c.mconn.Send(byte(chID), msg); !ok {
+		if ok := c.mconn.Send(chID, msg); !ok {
 			return errors.New("sending message timed out")
 		}
 
diff --git a/internal/p2p/transport_mconn_test.go b/internal/p2p/transport_mconn_test.go
index f4d7198edf..d334381096 100644
--- a/internal/p2p/transport_mconn_test.go
+++ b/internal/p2p/transport_mconn_test.go
@@ -21,7 +21,7 @@ func init() {
 		transport := p2p.NewMConnTransport(
 			log.TestingLogger(),
 			conn.DefaultMConnConfig(),
-			[]*p2p.ChannelDescriptor{{ID: byte(chID), Priority: 1}},
+			[]*p2p.ChannelDescriptor{{ID: chID, Priority: 1}},
 			p2p.MConnTransportOptions{},
 		)
 		err := transport.Listen(p2p.Endpoint{
@@ -43,7 +43,7 @@ func TestMConnTransport_AcceptBeforeListen(t *testing.T) {
 	transport := p2p.NewMConnTransport(
 		log.TestingLogger(),
 		conn.DefaultMConnConfig(),
-		[]*p2p.ChannelDescriptor{{ID: byte(chID), Priority: 1}},
+		[]*p2p.ChannelDescriptor{{ID: chID, Priority: 1}},
 		p2p.MConnTransportOptions{
 			MaxAcceptedConnections: 2,
 		},
@@ -61,7 +61,7 @@ func TestMConnTransport_AcceptMaxAcceptedConnections(t *testing.T) {
 	transport := p2p.NewMConnTransport(
 		log.TestingLogger(),
 		conn.DefaultMConnConfig(),
-		[]*p2p.ChannelDescriptor{{ID: byte(chID), Priority: 1}},
+		[]*p2p.ChannelDescriptor{{ID: chID, Priority: 1}},
 		p2p.MConnTransportOptions{
 			MaxAcceptedConnections: 2,
 		},
@@ -148,7 +148,7 @@ func TestMConnTransport_Listen(t *testing.T) {
 			transport := p2p.NewMConnTransport(
 				log.TestingLogger(),
 				conn.DefaultMConnConfig(),
-				[]*p2p.ChannelDescriptor{{ID: byte(chID), Priority: 1}},
+				[]*p2p.ChannelDescriptor{{ID: chID, Priority: 1}},
 				p2p.MConnTransportOptions{},
 			)
 
diff --git a/internal/p2p/transport_memory.go b/internal/p2p/transport_memory.go
index 853288c59f..b4161ecd65 100644
--- a/internal/p2p/transport_memory.go
+++ b/internal/p2p/transport_memory.go
@@ -117,6 +117,8 @@ func (t *MemoryTransport) String() string {
 	return string(MemoryProtocol)
 }
 
+func (t *MemoryTransport) AddChannelDescriptors([]*ChannelDescriptor) {}
+
 // Protocols implements Transport.
 func (t *MemoryTransport) Protocols() []Protocol {
 	return []Protocol{MemoryProtocol}
diff --git a/internal/p2p/types.go b/internal/p2p/types.go
index 388ff2253b..bee99a4fe6 100644
--- a/internal/p2p/types.go
+++ b/internal/p2p/types.go
@@ -5,3 +5,4 @@ import (
 )
 
 type ChannelDescriptor = conn.ChannelDescriptor
+type ChannelID = conn.ChannelID
diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index 3757d028d9..86a46ea633 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -39,7 +39,7 @@ var (
 	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
 		SnapshotChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(SnapshotChannel),
+				ID:                  SnapshotChannel,
 				MessageType:         new(ssproto.Message),
 				Priority:            6,
 				SendQueueCapacity:   10,
@@ -49,7 +49,7 @@ var (
 		},
 		ChunkChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(ChunkChannel),
+				ID:                  ChunkChannel,
 				Priority:            3,
 				MessageType:         new(ssproto.Message),
 				SendQueueCapacity:   4,
@@ -59,7 +59,7 @@ var (
 		},
 		LightBlockChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(LightBlockChannel),
+				ID:                  LightBlockChannel,
 				MessageType:         new(ssproto.Message),
 				Priority:            5,
 				SendQueueCapacity:   10,
@@ -69,7 +69,7 @@ var (
 		},
 		ParamsChannel: {
 			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  byte(ParamsChannel),
+				ID:                  ParamsChannel,
 				MessageType:         new(ssproto.Message),
 				Priority:            2,
 				SendQueueCapacity:   10,
diff --git a/node/node.go b/node/node.go
index 6a66f42244..61ba257495 100644
--- a/node/node.go
+++ b/node/node.go
@@ -19,7 +19,6 @@ import (
 	"github.com/tendermint/tendermint/internal/consensus"
 	"github.com/tendermint/tendermint/internal/mempool"
 	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/p2p/pex"
 	"github.com/tendermint/tendermint/internal/proxy"
 	rpccore "github.com/tendermint/tendermint/internal/rpc/core"
 	sm "github.com/tendermint/tendermint/internal/state"
@@ -277,7 +276,7 @@ func makeNode(cfg *config.Config,
 			makeCloser(closers))
 	}
 
-	mpReactorShim, mpReactor, mp, err := createMempoolReactor(
+	mpReactor, mp, err := createMempoolReactor(
 		cfg, proxyApp, state, nodeMetrics.mempool, peerManager, router, logger,
 	)
 	if err != nil {
@@ -285,7 +284,7 @@ func makeNode(cfg *config.Config,
 
 	}
 
-	evReactorShim, evReactor, evPool, err := createEvidenceReactor(
+	evReactor, evPool, err := createEvidenceReactor(
 		cfg, dbProvider, stateDB, blockStore, peerManager, router, logger,
 	)
 	if err != nil {
@@ -304,7 +303,7 @@ func makeNode(cfg *config.Config,
 		sm.BlockExecutorWithMetrics(nodeMetrics.state),
 	)
 
-	csReactorShim, csReactor, csState := createConsensusReactor(
+	csReactor, csState := createConsensusReactor(
 		cfg, state, blockExec, blockStore, mp, evPool,
 		privValidator, nodeMetrics.consensus, stateSync || blockSync, eventBus,
 		peerManager, router, consensusLogger,
@@ -312,7 +311,7 @@ func makeNode(cfg *config.Config,
 
 	// Create the blockchain reactor. Note, we do not start block sync if we're
 	// doing a state sync first.
-	bcReactorShim, bcReactor, err := createBlockchainReactor(
+	bcReactor, err := createBlockchainReactor(
 		logger, state, blockExec, blockStore, csReactor,
 		peerManager, router, blockSync && !stateSync, nodeMetrics.consensus,
 	)
@@ -335,7 +334,6 @@ func makeNode(cfg *config.Config,
 	// we should clean this whole thing up. See:
 	// https://github.com/tendermint/tendermint/issues/4644
 	ssLogger := logger.With("module", "statesync")
-	ssReactorShim := p2p.NewReactorShim(ssLogger, "StateSyncShim", statesync.ChannelShims)
 	channels := makeChannelsFromShims(router, statesync.ChannelShims)
 
 	peerUpdates := peerManager.Subscribe()
@@ -357,16 +355,6 @@ func makeNode(cfg *config.Config,
 		nodeMetrics.statesync,
 	)
 
-	// add the channel descriptors to both the transports
-	// FIXME: This should be removed when the legacy p2p stack is removed and
-	// transports can either be agnostic to channel descriptors or can be
-	// declared in the constructor.
-	transport.AddChannelDescriptors(mpReactorShim.GetChannels())
-	transport.AddChannelDescriptors(bcReactorShim.GetChannels())
-	transport.AddChannelDescriptors(csReactorShim.GetChannels())
-	transport.AddChannelDescriptors(evReactorShim.GetChannels())
-	transport.AddChannelDescriptors(ssReactorShim.GetChannels())
-
 	// Optionally, start the pex reactor
 	//
 	// TODO:
@@ -382,9 +370,6 @@ func makeNode(cfg *config.Config,
 
 	var pexReactor service.Service
 
-	pexCh := pex.ChannelDescriptor()
-	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
-
 	pexReactor, err = createPEXReactor(logger, peerManager, router)
 	if err != nil {
 		return nil, combineCloseError(err, makeCloser(closers))
@@ -501,13 +486,6 @@ func makeSeedNode(cfg *config.Config,
 
 	var pexReactor service.Service
 
-	// add the pex reactor
-	// FIXME: we add channel descriptors to both the router and the transport but only the router
-	// should be aware of channel info. We should remove this from transport once the legacy
-	// p2p stack is removed.
-	pexCh := pex.ChannelDescriptor()
-	transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh})
-
 	pexReactor, err = createPEXReactor(logger, peerManager, router)
 	if err != nil {
 		return nil, combineCloseError(err, closer)
diff --git a/node/setup.go b/node/setup.go
index a3491c995c..fb5599dfc9 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -196,11 +196,10 @@ func createMempoolReactor(
 	peerManager *p2p.PeerManager,
 	router *p2p.Router,
 	logger log.Logger,
-) (*p2p.ReactorShim, service.Service, mempool.Mempool, error) {
+) (service.Service, mempool.Mempool, error) {
 
 	logger = logger.With("module", "mempool", "version", cfg.Mempool.Version)
 	channelShims := mempoolv0.GetChannelShims(cfg.Mempool)
-	reactorShim := p2p.NewReactorShim(logger, "MempoolShim", channelShims)
 
 	channels := makeChannelsFromShims(router, channelShims)
 	peerUpdates := peerManager.Subscribe()
@@ -231,7 +230,7 @@ func createMempoolReactor(
 			mp.EnableTxsAvailable()
 		}
 
-		return reactorShim, reactor, mp, nil
+		return reactor, mp, nil
 
 	case config.MempoolV1:
 		mp := mempoolv1.NewTxMempool(
@@ -257,10 +256,10 @@ func createMempoolReactor(
 			mp.EnableTxsAvailable()
 		}
 
-		return reactorShim, reactor, mp, nil
+		return reactor, mp, nil
 
 	default:
-		return nil, nil, nil, fmt.Errorf("unknown mempool version: %s", cfg.Mempool.Version)
+		return nil, nil, fmt.Errorf("unknown mempool version: %s", cfg.Mempool.Version)
 	}
 }
 
@@ -272,18 +271,17 @@ func createEvidenceReactor(
 	peerManager *p2p.PeerManager,
 	router *p2p.Router,
 	logger log.Logger,
-) (*p2p.ReactorShim, *evidence.Reactor, *evidence.Pool, error) {
+) (*evidence.Reactor, *evidence.Pool, error) {
 	evidenceDB, err := dbProvider(&config.DBContext{ID: "evidence", Config: cfg})
 	if err != nil {
-		return nil, nil, nil, err
+		return nil, nil, err
 	}
 
 	logger = logger.With("module", "evidence")
-	reactorShim := p2p.NewReactorShim(logger, "EvidenceShim", evidence.ChannelShims)
 
 	evidencePool, err := evidence.NewPool(logger, evidenceDB, sm.NewStore(stateDB), blockStore)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("creating evidence pool: %w", err)
+		return nil, nil, fmt.Errorf("creating evidence pool: %w", err)
 	}
 
 	evidenceReactor := evidence.NewReactor(
@@ -293,7 +291,7 @@ func createEvidenceReactor(
 		evidencePool,
 	)
 
-	return reactorShim, evidenceReactor, evidencePool, nil
+	return evidenceReactor, evidencePool, nil
 }
 
 func createBlockchainReactor(
@@ -306,11 +304,10 @@ func createBlockchainReactor(
 	router *p2p.Router,
 	blockSync bool,
 	metrics *consensus.Metrics,
-) (*p2p.ReactorShim, service.Service, error) {
+) (service.Service, error) {
 
 	logger = logger.With("module", "blockchain")
 
-	reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", blocksync.ChannelShims)
 	channels := makeChannelsFromShims(router, blocksync.ChannelShims)
 	peerUpdates := peerManager.Subscribe()
 
@@ -320,10 +317,10 @@ func createBlockchainReactor(
 		metrics,
 	)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
 
-	return reactorShim, reactor, nil
+	return reactor, nil
 }
 
 func createConsensusReactor(
@@ -340,7 +337,7 @@ func createConsensusReactor(
 	peerManager *p2p.PeerManager,
 	router *p2p.Router,
 	logger log.Logger,
-) (*p2p.ReactorShim, *consensus.Reactor, *consensus.State) {
+) (*consensus.Reactor, *consensus.State) {
 
 	consensusState := consensus.NewState(
 		cfg.Consensus,
@@ -356,8 +353,6 @@ func createConsensusReactor(
 		consensusState.SetPrivValidator(privValidator)
 	}
 
-	reactorShim := p2p.NewReactorShim(logger, "ConsensusShim", consensus.ChannelShims)
-
 	var (
 		channels    map[p2p.ChannelID]*p2p.Channel
 		peerUpdates *p2p.PeerUpdates
@@ -382,7 +377,7 @@ func createConsensusReactor(
 	// consensusReactor will set it on consensusState and blockExecutor.
 	reactor.SetEventBus(eventBus)
 
-	return reactorShim, reactor, consensusState
+	return reactor, consensusState
 }
 
 func createTransport(logger log.Logger, cfg *config.Config) *p2p.MConnTransport {

From cbe6ad6cd5261963b0d05722f5ba0c549130d96f Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 15 Oct 2021 13:03:10 -0400
Subject: [PATCH 55/57] p2p: flatten channel descriptor (#7132)

---
 internal/blocksync/reactor.go       | 18 ++++----
 internal/blocksync/reactor_test.go  |  2 +-
 internal/consensus/reactor.go       | 72 +++++++++++++----------------
 internal/consensus/reactor_test.go  |  4 +-
 internal/evidence/reactor.go        | 16 +++----
 internal/evidence/reactor_test.go   |  2 +-
 internal/mempool/v0/reactor.go      | 18 ++++----
 internal/mempool/v0/reactor_test.go |  2 +-
 internal/mempool/v1/reactor.go      | 18 ++++----
 internal/mempool/v1/reactor_test.go |  2 +-
 internal/p2p/p2p_test.go            |  2 +-
 internal/p2p/p2ptest/network.go     | 12 ++---
 internal/p2p/pex/reactor.go         |  7 +--
 internal/p2p/pqueue.go              |  6 +--
 internal/p2p/pqueue_test.go         |  2 +-
 internal/p2p/router.go              |  8 ++--
 internal/p2p/router_test.go         |  2 +-
 internal/p2p/shim.go                |  9 ----
 internal/statesync/reactor.go       | 66 ++++++++++++--------------
 node/node.go                        | 11 +++--
 20 files changed, 124 insertions(+), 155 deletions(-)
 delete mode 100644 internal/p2p/shim.go

diff --git a/internal/blocksync/reactor.go b/internal/blocksync/reactor.go
index 86aaf79d3a..eebfda764e 100644
--- a/internal/blocksync/reactor.go
+++ b/internal/blocksync/reactor.go
@@ -27,16 +27,14 @@ var (
 	//
 	// TODO: Remove once p2p refactor is complete.
 	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
-		BlockSyncChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  BlockSyncChannel,
-				MessageType:         new(bcproto.Message),
-				Priority:            5,
-				SendQueueCapacity:   1000,
-				RecvBufferCapacity:  1024,
-				RecvMessageCapacity: MaxMsgSize,
-			},
+	ChannelShims = []*p2p.ChannelDescriptor{
+		{
+			ID:                  BlockSyncChannel,
+			MessageType:         new(bcproto.Message),
+			Priority:            5,
+			SendQueueCapacity:   1000,
+			RecvBufferCapacity:  1024,
+			RecvMessageCapacity: MaxMsgSize,
 		},
 	}
 )
diff --git a/internal/blocksync/reactor_test.go b/internal/blocksync/reactor_test.go
index 59889eec49..568b928a53 100644
--- a/internal/blocksync/reactor_test.go
+++ b/internal/blocksync/reactor_test.go
@@ -65,7 +65,7 @@ func setup(
 		blockSync:         true,
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: BlockSyncChannel}
+	chDesc := &p2p.ChannelDescriptor{ID: BlockSyncChannel}
 	rts.blockSyncChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(bcproto.Message), int(chBuf))
 
 	i := 0
diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go
index dde36306cd..eb8345b727 100644
--- a/internal/consensus/reactor.go
+++ b/internal/consensus/reactor.go
@@ -29,49 +29,41 @@ var (
 	//
 	// TODO: Remove once p2p refactor is complete.
 	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
-		StateChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  StateChannel,
-				MessageType:         new(tmcons.Message),
-				Priority:            8,
-				SendQueueCapacity:   64,
-				RecvMessageCapacity: maxMsgSize,
-				RecvBufferCapacity:  128,
-			},
+	ChannelShims = []*p2p.ChannelDescriptor{
+		{
+			ID:                  StateChannel,
+			MessageType:         new(tmcons.Message),
+			Priority:            8,
+			SendQueueCapacity:   64,
+			RecvMessageCapacity: maxMsgSize,
+			RecvBufferCapacity:  128,
 		},
-		DataChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				// TODO: Consider a split between gossiping current block and catchup
-				// stuff. Once we gossip the whole block there is nothing left to send
-				// until next height or round.
-				ID:                  DataChannel,
-				MessageType:         new(tmcons.Message),
-				Priority:            12,
-				SendQueueCapacity:   64,
-				RecvBufferCapacity:  512,
-				RecvMessageCapacity: maxMsgSize,
-			},
+		{
+			// TODO: Consider a split between gossiping current block and catchup
+			// stuff. Once we gossip the whole block there is nothing left to send
+			// until next height or round.
+			ID:                  DataChannel,
+			MessageType:         new(tmcons.Message),
+			Priority:            12,
+			SendQueueCapacity:   64,
+			RecvBufferCapacity:  512,
+			RecvMessageCapacity: maxMsgSize,
 		},
-		VoteChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  VoteChannel,
-				MessageType:         new(tmcons.Message),
-				Priority:            10,
-				SendQueueCapacity:   64,
-				RecvBufferCapacity:  128,
-				RecvMessageCapacity: maxMsgSize,
-			},
+		{
+			ID:                  VoteChannel,
+			MessageType:         new(tmcons.Message),
+			Priority:            10,
+			SendQueueCapacity:   64,
+			RecvBufferCapacity:  128,
+			RecvMessageCapacity: maxMsgSize,
 		},
-		VoteSetBitsChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  VoteSetBitsChannel,
-				MessageType:         new(tmcons.Message),
-				Priority:            5,
-				SendQueueCapacity:   8,
-				RecvBufferCapacity:  128,
-				RecvMessageCapacity: maxMsgSize,
-			},
+		{
+			ID:                  VoteSetBitsChannel,
+			MessageType:         new(tmcons.Message),
+			Priority:            5,
+			SendQueueCapacity:   8,
+			RecvBufferCapacity:  128,
+			RecvMessageCapacity: maxMsgSize,
 		},
 	}
 )
diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go
index 04bc3708ee..246178db4a 100644
--- a/internal/consensus/reactor_test.go
+++ b/internal/consensus/reactor_test.go
@@ -50,8 +50,8 @@ type reactorTestSuite struct {
 	voteSetBitsChannels map[types.NodeID]*p2p.Channel
 }
 
-func chDesc(chID p2p.ChannelID) p2p.ChannelDescriptor {
-	return p2p.ChannelDescriptor{
+func chDesc(chID p2p.ChannelID) *p2p.ChannelDescriptor {
+	return &p2p.ChannelDescriptor{
 		ID: chID,
 	}
 }
diff --git a/internal/evidence/reactor.go b/internal/evidence/reactor.go
index 0cf261441a..6f96b39062 100644
--- a/internal/evidence/reactor.go
+++ b/internal/evidence/reactor.go
@@ -25,15 +25,13 @@ var (
 	//
 	// TODO: Remove once p2p refactor is complete.
 	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
-		EvidenceChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  EvidenceChannel,
-				MessageType:         new(tmproto.EvidenceList),
-				Priority:            6,
-				RecvMessageCapacity: maxMsgSize,
-				RecvBufferCapacity:  32,
-			},
+	ChannelShims = []*p2p.ChannelDescriptor{
+		{
+			ID:                  EvidenceChannel,
+			MessageType:         new(tmproto.EvidenceList),
+			Priority:            6,
+			RecvMessageCapacity: maxMsgSize,
+			RecvBufferCapacity:  32,
 		},
 	}
 )
diff --git a/internal/evidence/reactor_test.go b/internal/evidence/reactor_test.go
index 7963ba959c..50db470126 100644
--- a/internal/evidence/reactor_test.go
+++ b/internal/evidence/reactor_test.go
@@ -62,7 +62,7 @@ func setup(t *testing.T, stateStores []sm.Store, chBuf uint) *reactorTestSuite {
 		peerChans:      make(map[types.NodeID]chan p2p.PeerUpdate, numStateStores),
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: evidence.EvidenceChannel}
+	chDesc := &p2p.ChannelDescriptor{ID: evidence.EvidenceChannel}
 	rts.evidenceChannels = rts.network.MakeChannelsNoCleanup(t,
 		chDesc,
 		new(tmproto.EvidenceList),
diff --git a/internal/mempool/v0/reactor.go b/internal/mempool/v0/reactor.go
index 010f98f5db..d2a6218292 100644
--- a/internal/mempool/v0/reactor.go
+++ b/internal/mempool/v0/reactor.go
@@ -90,7 +90,7 @@ func NewReactor(
 //
 // TODO: Remove once p2p refactor is complete.
 // ref: https://github.com/tendermint/tendermint/issues/5670
-func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDescriptorShim {
+func GetChannelShims(cfg *config.MempoolConfig) []*p2p.ChannelDescriptor {
 	largestTx := make([]byte, cfg.MaxTxBytes)
 	batchMsg := protomem.Message{
 		Sum: &protomem.Message_Txs{
@@ -98,15 +98,13 @@ func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe
 		},
 	}
 
-	return map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
-		mempool.MempoolChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  mempool.MempoolChannel,
-				MessageType:         new(protomem.Message),
-				Priority:            5,
-				RecvMessageCapacity: batchMsg.Size(),
-				RecvBufferCapacity:  128,
-			},
+	return []*p2p.ChannelDescriptor{
+		{
+			ID:                  mempool.MempoolChannel,
+			MessageType:         new(protomem.Message),
+			Priority:            5,
+			RecvMessageCapacity: batchMsg.Size(),
+			RecvBufferCapacity:  128,
 		},
 	}
 }
diff --git a/internal/mempool/v0/reactor_test.go b/internal/mempool/v0/reactor_test.go
index 4ae2523a14..2964018d67 100644
--- a/internal/mempool/v0/reactor_test.go
+++ b/internal/mempool/v0/reactor_test.go
@@ -50,7 +50,7 @@ func setup(t *testing.T, config *config.MempoolConfig, numNodes int, chBuf uint)
 		peerUpdates:    make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
+	chDesc := &p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
 	rts.mempoolChnnels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(protomem.Message), int(chBuf))
 
 	for nodeID := range rts.network.Nodes {
diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go
index 72154b4a88..e4b04c9319 100644
--- a/internal/mempool/v1/reactor.go
+++ b/internal/mempool/v1/reactor.go
@@ -97,7 +97,7 @@ func defaultObservePanic(r interface{}) {}
 //
 // TODO: Remove once p2p refactor is complete.
 // ref: https://github.com/tendermint/tendermint/issues/5670
-func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDescriptorShim {
+func GetChannelShims(cfg *config.MempoolConfig) []*p2p.ChannelDescriptor {
 	largestTx := make([]byte, cfg.MaxTxBytes)
 	batchMsg := protomem.Message{
 		Sum: &protomem.Message_Txs{
@@ -105,15 +105,13 @@ func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe
 		},
 	}
 
-	return map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
-		mempool.MempoolChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  mempool.MempoolChannel,
-				MessageType:         new(protomem.Message),
-				Priority:            5,
-				RecvMessageCapacity: batchMsg.Size(),
-				RecvBufferCapacity:  128,
-			},
+	return []*p2p.ChannelDescriptor{
+		{
+			ID:                  mempool.MempoolChannel,
+			MessageType:         new(protomem.Message),
+			Priority:            5,
+			RecvMessageCapacity: batchMsg.Size(),
+			RecvBufferCapacity:  128,
 		},
 	}
 }
diff --git a/internal/mempool/v1/reactor_test.go b/internal/mempool/v1/reactor_test.go
index 1449b20b1b..bdb66f4361 100644
--- a/internal/mempool/v1/reactor_test.go
+++ b/internal/mempool/v1/reactor_test.go
@@ -52,7 +52,7 @@ func setupReactors(t *testing.T, numNodes int, chBuf uint) *reactorTestSuite {
 		peerUpdates:     make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
+	chDesc := &p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
 	rts.mempoolChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(protomem.Message), int(chBuf))
 
 	for nodeID := range rts.network.Nodes {
diff --git a/internal/p2p/p2p_test.go b/internal/p2p/p2p_test.go
index f5ed5706c5..15e561d9b4 100644
--- a/internal/p2p/p2p_test.go
+++ b/internal/p2p/p2p_test.go
@@ -14,7 +14,7 @@ import (
 var (
 	ctx    = context.Background()
 	chID   = p2p.ChannelID(1)
-	chDesc = p2p.ChannelDescriptor{
+	chDesc = &p2p.ChannelDescriptor{
 		ID:                  chID,
 		Priority:            5,
 		SendQueueCapacity:   10,
diff --git a/internal/p2p/p2ptest/network.go b/internal/p2p/p2ptest/network.go
index 2ed8887643..dff5b6a75c 100644
--- a/internal/p2p/p2ptest/network.go
+++ b/internal/p2p/p2ptest/network.go
@@ -137,7 +137,7 @@ func (n *Network) NodeIDs() []types.NodeID {
 // doing error checks and cleanups.
 func (n *Network) MakeChannels(
 	t *testing.T,
-	chDesc p2p.ChannelDescriptor,
+	chDesc *p2p.ChannelDescriptor,
 	messageType proto.Message,
 	size int,
 ) map[types.NodeID]*p2p.Channel {
@@ -153,7 +153,7 @@ func (n *Network) MakeChannels(
 // all the channels.
 func (n *Network) MakeChannelsNoCleanup(
 	t *testing.T,
-	chDesc p2p.ChannelDescriptor,
+	chDesc *p2p.ChannelDescriptor,
 	messageType proto.Message,
 	size int,
 ) map[types.NodeID]*p2p.Channel {
@@ -281,7 +281,7 @@ func (n *Network) MakeNode(t *testing.T, opts NodeOptions) *Node {
 // MakeChannel opens a channel, with automatic error handling and cleanup. On
 // test cleanup, it also checks that the channel is empty, to make sure
 // all expected messages have been asserted.
-func (n *Node) MakeChannel(t *testing.T, chDesc p2p.ChannelDescriptor,
+func (n *Node) MakeChannel(t *testing.T, chDesc *p2p.ChannelDescriptor,
 	messageType proto.Message, size int) *p2p.Channel {
 	channel, err := n.Router.OpenChannel(chDesc, messageType, size)
 	require.NoError(t, err)
@@ -297,7 +297,7 @@ func (n *Node) MakeChannel(t *testing.T, chDesc p2p.ChannelDescriptor,
 // caller must ensure proper cleanup of the channel.
 func (n *Node) MakeChannelNoCleanup(
 	t *testing.T,
-	chDesc p2p.ChannelDescriptor,
+	chDesc *p2p.ChannelDescriptor,
 	messageType proto.Message,
 	size int,
 ) *p2p.Channel {
@@ -333,8 +333,8 @@ func (n *Node) MakePeerUpdatesNoRequireEmpty(t *testing.T) *p2p.PeerUpdates {
 	return sub
 }
 
-func MakeChannelDesc(chID p2p.ChannelID) p2p.ChannelDescriptor {
-	return p2p.ChannelDescriptor{
+func MakeChannelDesc(chID p2p.ChannelID) *p2p.ChannelDescriptor {
+	return &p2p.ChannelDescriptor{
 		ID:                  chID,
 		Priority:            5,
 		SendQueueCapacity:   10,
diff --git a/internal/p2p/pex/reactor.go b/internal/p2p/pex/reactor.go
index d43d836ce8..645cc19e13 100644
--- a/internal/p2p/pex/reactor.go
+++ b/internal/p2p/pex/reactor.go
@@ -62,13 +62,14 @@ const (
 // within each reactor (as they are now) or, considering that the reactor doesn't
 // really need to care about the channel descriptors, if they should be housed
 // in the node module.
-func ChannelDescriptor() conn.ChannelDescriptor {
-	return conn.ChannelDescriptor{
+func ChannelDescriptor() *conn.ChannelDescriptor {
+	return &conn.ChannelDescriptor{
 		ID:                  PexChannel,
+		MessageType:         new(protop2p.PexMessage),
 		Priority:            1,
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: maxMsgSize,
-		RecvBufferCapacity:  32,
+		RecvBufferCapacity:  128,
 	}
 }
 
diff --git a/internal/p2p/pqueue.go b/internal/p2p/pqueue.go
index fd0a43db68..e0e812cf5e 100644
--- a/internal/p2p/pqueue.go
+++ b/internal/p2p/pqueue.go
@@ -71,7 +71,7 @@ type pqScheduler struct {
 	size         uint
 	sizes        map[uint]uint // cumulative priority sizes
 	pq           *priorityQueue
-	chDescs      []ChannelDescriptor
+	chDescs      []*ChannelDescriptor
 	capacity     uint
 	chPriorities map[ChannelID]uint
 
@@ -84,12 +84,12 @@ type pqScheduler struct {
 func newPQScheduler(
 	logger log.Logger,
 	m *Metrics,
-	chDescs []ChannelDescriptor,
+	chDescs []*ChannelDescriptor,
 	enqueueBuf, dequeueBuf, capacity uint,
 ) *pqScheduler {
 
 	// copy each ChannelDescriptor and sort them by ascending channel priority
-	chDescsCopy := make([]ChannelDescriptor, len(chDescs))
+	chDescsCopy := make([]*ChannelDescriptor, len(chDescs))
 	copy(chDescsCopy, chDescs)
 	sort.Slice(chDescsCopy, func(i, j int) bool { return chDescsCopy[i].Priority < chDescsCopy[j].Priority })
 
diff --git a/internal/p2p/pqueue_test.go b/internal/p2p/pqueue_test.go
index 18f0c02e36..ffa7e39a8d 100644
--- a/internal/p2p/pqueue_test.go
+++ b/internal/p2p/pqueue_test.go
@@ -12,7 +12,7 @@ type testMessage = gogotypes.StringValue
 
 func TestCloseWhileDequeueFull(t *testing.T) {
 	enqueueLength := 5
-	chDescs := []ChannelDescriptor{
+	chDescs := []*ChannelDescriptor{
 		{ID: 0x01, Priority: 1},
 	}
 	pqueue := newPQScheduler(log.NewNopLogger(), NopMetrics(), chDescs, uint(enqueueLength), 1, 120)
diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index 11d0514bba..fbf2eea6b9 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -249,7 +249,7 @@ type Router struct {
 	nodeInfo           types.NodeInfo
 	privKey            crypto.PrivKey
 	peerManager        *PeerManager
-	chDescs            []ChannelDescriptor
+	chDescs            []*ChannelDescriptor
 	transports         []Transport
 	connTracker        connectionTracker
 	protocolTransports map[Protocol]Transport
@@ -295,7 +295,7 @@ func NewRouter(
 			options.MaxIncomingConnectionAttempts,
 			options.IncomingConnectionWindow,
 		),
-		chDescs:            make([]ChannelDescriptor, 0),
+		chDescs:            make([]*ChannelDescriptor, 0),
 		transports:         transports,
 		protocolTransports: map[Protocol]Transport{},
 		peerManager:        peerManager,
@@ -354,7 +354,7 @@ func (r *Router) createQueueFactory() (func(int) queue, error) {
 // implement Wrapper to automatically (un)wrap multiple message types in a
 // wrapper message. The caller may provide a size to make the channel buffered,
 // which internally makes the inbound, outbound, and error channel buffered.
-func (r *Router) OpenChannel(chDesc ChannelDescriptor, messageType proto.Message, size int) (*Channel, error) {
+func (r *Router) OpenChannel(chDesc *ChannelDescriptor, messageType proto.Message, size int) (*Channel, error) {
 	r.channelMtx.Lock()
 	defer r.channelMtx.Unlock()
 
@@ -381,7 +381,7 @@ func (r *Router) OpenChannel(chDesc ChannelDescriptor, messageType proto.Message
 	r.nodeInfo.AddChannel(uint16(chDesc.ID))
 
 	for _, t := range r.transports {
-		t.AddChannelDescriptors([]*ChannelDescriptor{&chDesc})
+		t.AddChannelDescriptors([]*ChannelDescriptor{chDesc})
 	}
 
 	go func() {
diff --git a/internal/p2p/router_test.go b/internal/p2p/router_test.go
index 7f922c29d7..7ba42b9b0b 100644
--- a/internal/p2p/router_test.go
+++ b/internal/p2p/router_test.go
@@ -128,7 +128,7 @@ func TestRouter_Channel_Basic(t *testing.T) {
 	require.Error(t, err)
 
 	// Opening a different channel should work.
-	chDesc2 := p2p.ChannelDescriptor{ID: 2}
+	chDesc2 := &p2p.ChannelDescriptor{ID: 2}
 	_, err = router.OpenChannel(chDesc2, &p2ptest.Message{}, 0)
 	require.NoError(t, err)
 	require.Contains(t, router.NodeInfo().Channels, byte(chDesc2.ID))
diff --git a/internal/p2p/shim.go b/internal/p2p/shim.go
deleted file mode 100644
index 8de0b71c71..0000000000
--- a/internal/p2p/shim.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package p2p
-
-// ChannelDescriptorShim defines a shim wrapper around a legacy p2p channel
-// and the proto.Message the new p2p Channel is responsible for handling.
-// A ChannelDescriptorShim is not contained in ReactorShim, but is rather
-// used to construct a ReactorShim.
-type ChannelDescriptorShim struct {
-	Descriptor *ChannelDescriptor
-}
diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index 86a46ea633..99cb4e6ab9 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -36,46 +36,38 @@ var (
 	//
 	// TODO: Remove once p2p refactor is complete.
 	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = map[p2p.ChannelID]*p2p.ChannelDescriptorShim{
-		SnapshotChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  SnapshotChannel,
-				MessageType:         new(ssproto.Message),
-				Priority:            6,
-				SendQueueCapacity:   10,
-				RecvMessageCapacity: snapshotMsgSize,
-				RecvBufferCapacity:  128,
-			},
+	ChannelShims = []*p2p.ChannelDescriptor{
+		{
+			ID:                  SnapshotChannel,
+			MessageType:         new(ssproto.Message),
+			Priority:            6,
+			SendQueueCapacity:   10,
+			RecvMessageCapacity: snapshotMsgSize,
+			RecvBufferCapacity:  128,
 		},
-		ChunkChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  ChunkChannel,
-				Priority:            3,
-				MessageType:         new(ssproto.Message),
-				SendQueueCapacity:   4,
-				RecvMessageCapacity: chunkMsgSize,
-				RecvBufferCapacity:  128,
-			},
+		{
+			ID:                  ChunkChannel,
+			Priority:            3,
+			MessageType:         new(ssproto.Message),
+			SendQueueCapacity:   4,
+			RecvMessageCapacity: chunkMsgSize,
+			RecvBufferCapacity:  128,
 		},
-		LightBlockChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  LightBlockChannel,
-				MessageType:         new(ssproto.Message),
-				Priority:            5,
-				SendQueueCapacity:   10,
-				RecvMessageCapacity: lightBlockMsgSize,
-				RecvBufferCapacity:  128,
-			},
+		{
+			ID:                  LightBlockChannel,
+			MessageType:         new(ssproto.Message),
+			Priority:            5,
+			SendQueueCapacity:   10,
+			RecvMessageCapacity: lightBlockMsgSize,
+			RecvBufferCapacity:  128,
 		},
-		ParamsChannel: {
-			Descriptor: &p2p.ChannelDescriptor{
-				ID:                  ParamsChannel,
-				MessageType:         new(ssproto.Message),
-				Priority:            2,
-				SendQueueCapacity:   10,
-				RecvMessageCapacity: paramMsgSize,
-				RecvBufferCapacity:  128,
-			},
+		{
+			ID:                  ParamsChannel,
+			MessageType:         new(ssproto.Message),
+			Priority:            2,
+			SendQueueCapacity:   10,
+			RecvMessageCapacity: paramMsgSize,
+			RecvBufferCapacity:  128,
 		},
 	}
 )
diff --git a/node/node.go b/node/node.go
index 61ba257495..cf2d104dc7 100644
--- a/node/node.go
+++ b/node/node.go
@@ -1092,17 +1092,18 @@ func getRouterConfig(conf *config.Config, proxyApp proxy.AppConns) p2p.RouterOpt
 // FIXME: Temporary helper function, shims should be removed.
 func makeChannelsFromShims(
 	router *p2p.Router,
-	chShims map[p2p.ChannelID]*p2p.ChannelDescriptorShim,
+	chDescs []*p2p.ChannelDescriptor,
 ) map[p2p.ChannelID]*p2p.Channel {
 
 	channels := map[p2p.ChannelID]*p2p.Channel{}
-	for chID, chShim := range chShims {
-		ch, err := router.OpenChannel(*chShim.Descriptor, chShim.Descriptor.MessageType, chShim.Descriptor.RecvBufferCapacity)
+	for idx := range chDescs {
+		chDesc := chDescs[idx]
+		ch, err := router.OpenChannel(chDesc, chDesc.MessageType, chDesc.RecvBufferCapacity)
 		if err != nil {
-			panic(fmt.Sprintf("failed to open channel %v: %v", chID, err))
+			panic(fmt.Sprintf("failed to open channel %v: %v", chDesc.ID, err))
 		}
 
-		channels[chID] = ch
+		channels[chDesc.ID] = ch
 	}
 
 	return channels

From 7143f14a633cc9420c122309c252f19a2ef701e5 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 15 Oct 2021 14:00:24 -0400
Subject: [PATCH 56/57] p2p: simplify open channel interface (#7133)

A fourth #7075 component patch to simplify the channel creation interface
---
 internal/blocksync/reactor_test.go  |  4 ++--
 internal/consensus/reactor_test.go  | 14 ++++++------
 internal/evidence/reactor_test.go   |  7 ++----
 internal/mempool/v0/reactor_test.go |  5 +++--
 internal/mempool/v1/reactor_test.go |  6 ++----
 internal/p2p/p2p_test.go            |  2 ++
 internal/p2p/p2ptest/network.go     | 23 ++++++++------------
 internal/p2p/p2ptest/require.go     |  2 ++
 internal/p2p/pex/reactor_test.go    |  8 ++-----
 internal/p2p/router.go              | 10 +++++----
 internal/p2p/router_test.go         | 33 ++++++++++++++++++-----------
 node/node.go                        |  2 +-
 node/setup.go                       |  3 +--
 13 files changed, 61 insertions(+), 58 deletions(-)

diff --git a/internal/blocksync/reactor_test.go b/internal/blocksync/reactor_test.go
index 568b928a53..6bca8d4a92 100644
--- a/internal/blocksync/reactor_test.go
+++ b/internal/blocksync/reactor_test.go
@@ -65,8 +65,8 @@ func setup(
 		blockSync:         true,
 	}
 
-	chDesc := &p2p.ChannelDescriptor{ID: BlockSyncChannel}
-	rts.blockSyncChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(bcproto.Message), int(chBuf))
+	chDesc := &p2p.ChannelDescriptor{ID: BlockSyncChannel, MessageType: new(bcproto.Message)}
+	rts.blockSyncChannels = rts.network.MakeChannelsNoCleanup(t, chDesc)
 
 	i := 0
 	for nodeID := range rts.network.Nodes {
diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go
index 246178db4a..16fa139694 100644
--- a/internal/consensus/reactor_test.go
+++ b/internal/consensus/reactor_test.go
@@ -50,9 +50,11 @@ type reactorTestSuite struct {
 	voteSetBitsChannels map[types.NodeID]*p2p.Channel
 }
 
-func chDesc(chID p2p.ChannelID) *p2p.ChannelDescriptor {
+func chDesc(chID p2p.ChannelID, size int) *p2p.ChannelDescriptor {
 	return &p2p.ChannelDescriptor{
-		ID: chID,
+		ID:                 chID,
+		MessageType:        new(tmcons.Message),
+		RecvBufferCapacity: size,
 	}
 }
 
@@ -67,10 +69,10 @@ func setup(t *testing.T, numNodes int, states []*State, size int) *reactorTestSu
 		blocksyncSubs: make(map[types.NodeID]types.Subscription, numNodes),
 	}
 
-	rts.stateChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(StateChannel), new(tmcons.Message), size)
-	rts.dataChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(DataChannel), new(tmcons.Message), size)
-	rts.voteChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(VoteChannel), new(tmcons.Message), size)
-	rts.voteSetBitsChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(VoteSetBitsChannel), new(tmcons.Message), size)
+	rts.stateChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(StateChannel, size))
+	rts.dataChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(DataChannel, size))
+	rts.voteChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(VoteChannel, size))
+	rts.voteSetBitsChannels = rts.network.MakeChannelsNoCleanup(t, chDesc(VoteSetBitsChannel, size))
 
 	_, cancel := context.WithCancel(context.Background())
 
diff --git a/internal/evidence/reactor_test.go b/internal/evidence/reactor_test.go
index 50db470126..cf8f840ead 100644
--- a/internal/evidence/reactor_test.go
+++ b/internal/evidence/reactor_test.go
@@ -62,11 +62,8 @@ func setup(t *testing.T, stateStores []sm.Store, chBuf uint) *reactorTestSuite {
 		peerChans:      make(map[types.NodeID]chan p2p.PeerUpdate, numStateStores),
 	}
 
-	chDesc := &p2p.ChannelDescriptor{ID: evidence.EvidenceChannel}
-	rts.evidenceChannels = rts.network.MakeChannelsNoCleanup(t,
-		chDesc,
-		new(tmproto.EvidenceList),
-		int(chBuf))
+	chDesc := &p2p.ChannelDescriptor{ID: evidence.EvidenceChannel, MessageType: new(tmproto.EvidenceList)}
+	rts.evidenceChannels = rts.network.MakeChannelsNoCleanup(t, chDesc)
 	require.Len(t, rts.network.RandomNode().PeerManager.Peers(), 0)
 
 	idx := 0
diff --git a/internal/mempool/v0/reactor_test.go b/internal/mempool/v0/reactor_test.go
index 2964018d67..104e1d4bd3 100644
--- a/internal/mempool/v0/reactor_test.go
+++ b/internal/mempool/v0/reactor_test.go
@@ -50,8 +50,9 @@ func setup(t *testing.T, config *config.MempoolConfig, numNodes int, chBuf uint)
 		peerUpdates:    make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := &p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
-	rts.mempoolChnnels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(protomem.Message), int(chBuf))
+	chDesc := GetChannelShims(config)[0]
+	chDesc.RecvBufferCapacity = int(chBuf)
+	rts.mempoolChnnels = rts.network.MakeChannelsNoCleanup(t, chDesc)
 
 	for nodeID := range rts.network.Nodes {
 		rts.kvstores[nodeID] = kvstore.NewApplication()
diff --git a/internal/mempool/v1/reactor_test.go b/internal/mempool/v1/reactor_test.go
index bdb66f4361..f004e75a9c 100644
--- a/internal/mempool/v1/reactor_test.go
+++ b/internal/mempool/v1/reactor_test.go
@@ -10,11 +10,9 @@ import (
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/config"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/mempool"
 	"github.com/tendermint/tendermint/internal/p2p"
 	"github.com/tendermint/tendermint/internal/p2p/p2ptest"
 	"github.com/tendermint/tendermint/libs/log"
-	protomem "github.com/tendermint/tendermint/proto/tendermint/mempool"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -52,8 +50,8 @@ func setupReactors(t *testing.T, numNodes int, chBuf uint) *reactorTestSuite {
 		peerUpdates:     make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := &p2p.ChannelDescriptor{ID: mempool.MempoolChannel}
-	rts.mempoolChannels = rts.network.MakeChannelsNoCleanup(t, chDesc, new(protomem.Message), int(chBuf))
+	chDesc := GetChannelShims(cfg.Mempool)[0]
+	rts.mempoolChannels = rts.network.MakeChannelsNoCleanup(t, chDesc)
 
 	for nodeID := range rts.network.Nodes {
 		rts.kvstores[nodeID] = kvstore.NewApplication()
diff --git a/internal/p2p/p2p_test.go b/internal/p2p/p2p_test.go
index 15e561d9b4..642114a1d8 100644
--- a/internal/p2p/p2p_test.go
+++ b/internal/p2p/p2p_test.go
@@ -6,6 +6,7 @@ import (
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/internal/p2p"
+	"github.com/tendermint/tendermint/internal/p2p/p2ptest"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -16,6 +17,7 @@ var (
 	chID   = p2p.ChannelID(1)
 	chDesc = &p2p.ChannelDescriptor{
 		ID:                  chID,
+		MessageType:         &p2ptest.Message{},
 		Priority:            5,
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: 10,
diff --git a/internal/p2p/p2ptest/network.go b/internal/p2p/p2ptest/network.go
index dff5b6a75c..c808ad3e05 100644
--- a/internal/p2p/p2ptest/network.go
+++ b/internal/p2p/p2ptest/network.go
@@ -6,7 +6,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/require"
 	dbm "github.com/tendermint/tm-db"
 
@@ -138,12 +137,10 @@ func (n *Network) NodeIDs() []types.NodeID {
 func (n *Network) MakeChannels(
 	t *testing.T,
 	chDesc *p2p.ChannelDescriptor,
-	messageType proto.Message,
-	size int,
 ) map[types.NodeID]*p2p.Channel {
 	channels := map[types.NodeID]*p2p.Channel{}
 	for _, node := range n.Nodes {
-		channels[node.NodeID] = node.MakeChannel(t, chDesc, messageType, size)
+		channels[node.NodeID] = node.MakeChannel(t, chDesc)
 	}
 	return channels
 }
@@ -154,12 +151,10 @@ func (n *Network) MakeChannels(
 func (n *Network) MakeChannelsNoCleanup(
 	t *testing.T,
 	chDesc *p2p.ChannelDescriptor,
-	messageType proto.Message,
-	size int,
 ) map[types.NodeID]*p2p.Channel {
 	channels := map[types.NodeID]*p2p.Channel{}
 	for _, node := range n.Nodes {
-		channels[node.NodeID] = node.MakeChannelNoCleanup(t, chDesc, messageType, size)
+		channels[node.NodeID] = node.MakeChannelNoCleanup(t, chDesc)
 	}
 	return channels
 }
@@ -281,9 +276,11 @@ func (n *Network) MakeNode(t *testing.T, opts NodeOptions) *Node {
 // MakeChannel opens a channel, with automatic error handling and cleanup. On
 // test cleanup, it also checks that the channel is empty, to make sure
 // all expected messages have been asserted.
-func (n *Node) MakeChannel(t *testing.T, chDesc *p2p.ChannelDescriptor,
-	messageType proto.Message, size int) *p2p.Channel {
-	channel, err := n.Router.OpenChannel(chDesc, messageType, size)
+func (n *Node) MakeChannel(
+	t *testing.T,
+	chDesc *p2p.ChannelDescriptor,
+) *p2p.Channel {
+	channel, err := n.Router.OpenChannel(chDesc)
 	require.NoError(t, err)
 	require.Contains(t, n.Router.NodeInfo().Channels, byte(chDesc.ID))
 	t.Cleanup(func() {
@@ -298,11 +295,8 @@ func (n *Node) MakeChannel(t *testing.T, chDesc *p2p.ChannelDescriptor,
 func (n *Node) MakeChannelNoCleanup(
 	t *testing.T,
 	chDesc *p2p.ChannelDescriptor,
-	messageType proto.Message,
-	size int,
 ) *p2p.Channel {
-
-	channel, err := n.Router.OpenChannel(chDesc, messageType, size)
+	channel, err := n.Router.OpenChannel(chDesc)
 	require.NoError(t, err)
 	return channel
 }
@@ -336,6 +330,7 @@ func (n *Node) MakePeerUpdatesNoRequireEmpty(t *testing.T) *p2p.PeerUpdates {
 func MakeChannelDesc(chID p2p.ChannelID) *p2p.ChannelDescriptor {
 	return &p2p.ChannelDescriptor{
 		ID:                  chID,
+		MessageType:         &Message{},
 		Priority:            5,
 		SendQueueCapacity:   10,
 		RecvMessageCapacity: 10,
diff --git a/internal/p2p/p2ptest/require.go b/internal/p2p/p2ptest/require.go
index 3598baba07..a9fc16a34c 100644
--- a/internal/p2p/p2ptest/require.go
+++ b/internal/p2p/p2ptest/require.go
@@ -24,6 +24,8 @@ func RequireEmpty(t *testing.T, channels ...*p2p.Channel) {
 
 // RequireReceive requires that the given envelope is received on the channel.
 func RequireReceive(t *testing.T, channel *p2p.Channel, expect p2p.Envelope) {
+	t.Helper()
+
 	timer := time.NewTimer(time.Second) // not time.After due to goroutine leaks
 	defer timer.Stop()
 
diff --git a/internal/p2p/pex/reactor_test.go b/internal/p2p/pex/reactor_test.go
index 28476e67d2..b7e1a01c3d 100644
--- a/internal/p2p/pex/reactor_test.go
+++ b/internal/p2p/pex/reactor_test.go
@@ -380,9 +380,7 @@ func setupNetwork(t *testing.T, opts testOptions) *reactorTestSuite {
 
 	// NOTE: we don't assert that the channels get drained after stopping the
 	// reactor
-	rts.pexChannels = rts.network.MakeChannelsNoCleanup(
-		t, pex.ChannelDescriptor(), new(p2pproto.PexMessage), chBuf,
-	)
+	rts.pexChannels = rts.network.MakeChannelsNoCleanup(t, pex.ChannelDescriptor())
 
 	idx := 0
 	for nodeID := range rts.network.Nodes {
@@ -446,9 +444,7 @@ func (r *reactorTestSuite) addNodes(t *testing.T, nodes int) {
 		})
 		r.network.Nodes[node.NodeID] = node
 		nodeID := node.NodeID
-		r.pexChannels[nodeID] = node.MakeChannelNoCleanup(
-			t, pex.ChannelDescriptor(), new(p2pproto.PexMessage), r.opts.BufferSize,
-		)
+		r.pexChannels[nodeID] = node.MakeChannelNoCleanup(t, pex.ChannelDescriptor())
 		r.peerChans[nodeID] = make(chan p2p.PeerUpdate, r.opts.BufferSize)
 		r.peerUpdates[nodeID] = p2p.NewPeerUpdates(r.peerChans[nodeID], r.opts.BufferSize)
 		r.network.Nodes[nodeID].PeerManager.Register(r.peerUpdates[nodeID])
diff --git a/internal/p2p/router.go b/internal/p2p/router.go
index fbf2eea6b9..6c46946244 100644
--- a/internal/p2p/router.go
+++ b/internal/p2p/router.go
@@ -354,7 +354,7 @@ func (r *Router) createQueueFactory() (func(int) queue, error) {
 // implement Wrapper to automatically (un)wrap multiple message types in a
 // wrapper message. The caller may provide a size to make the channel buffered,
 // which internally makes the inbound, outbound, and error channel buffered.
-func (r *Router) OpenChannel(chDesc *ChannelDescriptor, messageType proto.Message, size int) (*Channel, error) {
+func (r *Router) OpenChannel(chDesc *ChannelDescriptor) (*Channel, error) {
 	r.channelMtx.Lock()
 	defer r.channelMtx.Unlock()
 
@@ -364,9 +364,11 @@ func (r *Router) OpenChannel(chDesc *ChannelDescriptor, messageType proto.Messag
 	}
 	r.chDescs = append(r.chDescs, chDesc)
 
-	queue := r.queueFactory(size)
-	outCh := make(chan Envelope, size)
-	errCh := make(chan PeerError, size)
+	messageType := chDesc.MessageType
+
+	queue := r.queueFactory(chDesc.RecvBufferCapacity)
+	outCh := make(chan Envelope, chDesc.RecvBufferCapacity)
+	errCh := make(chan PeerError, chDesc.RecvBufferCapacity)
 	channel := NewChannel(id, messageType, queue.dequeue(), outCh, errCh)
 
 	var wrapper Wrapper
diff --git a/internal/p2p/router_test.go b/internal/p2p/router_test.go
index 7ba42b9b0b..997f02a06f 100644
--- a/internal/p2p/router_test.go
+++ b/internal/p2p/router_test.go
@@ -50,7 +50,7 @@ func TestRouter_Network(t *testing.T) {
 	network := p2ptest.MakeNetwork(t, p2ptest.NetworkOptions{NumNodes: 8})
 	local := network.RandomNode()
 	peers := network.Peers(local.NodeID)
-	channels := network.MakeChannels(t, chDesc, &p2ptest.Message{}, 0)
+	channels := network.MakeChannels(t, chDesc)
 
 	network.Start(t)
 
@@ -119,17 +119,18 @@ func TestRouter_Channel_Basic(t *testing.T) {
 	})
 
 	// Opening a channel should work.
-	channel, err := router.OpenChannel(chDesc, &p2ptest.Message{}, 0)
+	channel, err := router.OpenChannel(chDesc)
 	require.NoError(t, err)
 	require.Contains(t, router.NodeInfo().Channels, byte(chDesc.ID))
 
 	// Opening the same channel again should fail.
-	_, err = router.OpenChannel(chDesc, &p2ptest.Message{}, 0)
+	_, err = router.OpenChannel(chDesc)
 	require.Error(t, err)
 
 	// Opening a different channel should work.
-	chDesc2 := &p2p.ChannelDescriptor{ID: 2}
-	_, err = router.OpenChannel(chDesc2, &p2ptest.Message{}, 0)
+	chDesc2 := &p2p.ChannelDescriptor{ID: 2, MessageType: &p2ptest.Message{}}
+	_, err = router.OpenChannel(chDesc2)
+
 	require.NoError(t, err)
 	require.Contains(t, router.NodeInfo().Channels, byte(chDesc2.ID))
 
@@ -137,7 +138,7 @@ func TestRouter_Channel_Basic(t *testing.T) {
 	channel.Close()
 	time.Sleep(100 * time.Millisecond) // yes yes, but Close() is async...
 
-	channel, err = router.OpenChannel(chDesc, &p2ptest.Message{}, 0)
+	channel, err = router.OpenChannel(chDesc)
 	require.NoError(t, err)
 
 	// We should be able to send on the channel, even though there are no peers.
@@ -163,9 +164,9 @@ func TestRouter_Channel_SendReceive(t *testing.T) {
 
 	ids := network.NodeIDs()
 	aID, bID, cID := ids[0], ids[1], ids[2]
-	channels := network.MakeChannels(t, chDesc, &p2ptest.Message{}, 0)
+	channels := network.MakeChannels(t, chDesc)
 	a, b, c := channels[aID], channels[bID], channels[cID]
-	otherChannels := network.MakeChannels(t, p2ptest.MakeChannelDesc(9), &p2ptest.Message{}, 0)
+	otherChannels := network.MakeChannels(t, p2ptest.MakeChannelDesc(9))
 
 	network.Start(t)
 
@@ -222,7 +223,7 @@ func TestRouter_Channel_Broadcast(t *testing.T) {
 
 	ids := network.NodeIDs()
 	aID, bID, cID, dID := ids[0], ids[1], ids[2], ids[3]
-	channels := network.MakeChannels(t, chDesc, &p2ptest.Message{}, 0)
+	channels := network.MakeChannels(t, chDesc)
 	a, b, c, d := channels[aID], channels[bID], channels[cID], channels[dID]
 
 	network.Start(t)
@@ -250,7 +251,15 @@ func TestRouter_Channel_Wrapper(t *testing.T) {
 
 	ids := network.NodeIDs()
 	aID, bID := ids[0], ids[1]
-	channels := network.MakeChannels(t, chDesc, &wrapperMessage{}, 0)
+	chDesc := &p2p.ChannelDescriptor{
+		ID:                  chID,
+		MessageType:         &wrapperMessage{},
+		Priority:            5,
+		SendQueueCapacity:   10,
+		RecvMessageCapacity: 10,
+	}
+
+	channels := network.MakeChannels(t, chDesc)
 	a, b := channels[aID], channels[bID]
 
 	network.Start(t)
@@ -310,7 +319,7 @@ func TestRouter_Channel_Error(t *testing.T) {
 
 	ids := network.NodeIDs()
 	aID, bID := ids[0], ids[1]
-	channels := network.MakeChannels(t, chDesc, &p2ptest.Message{}, 0)
+	channels := network.MakeChannels(t, chDesc)
 	a := channels[aID]
 
 	// Erroring b should cause it to be disconnected. It will reconnect shortly after.
@@ -897,7 +906,7 @@ func TestRouter_DontSendOnInvalidChannel(t *testing.T) {
 		Status: p2p.PeerStatusUp,
 	})
 
-	channel, err := router.OpenChannel(chDesc, &p2ptest.Message{}, 0)
+	channel, err := router.OpenChannel(chDesc)
 	require.NoError(t, err)
 
 	channel.Out <- p2p.Envelope{
diff --git a/node/node.go b/node/node.go
index cf2d104dc7..0a48bf0b7a 100644
--- a/node/node.go
+++ b/node/node.go
@@ -1098,7 +1098,7 @@ func makeChannelsFromShims(
 	channels := map[p2p.ChannelID]*p2p.Channel{}
 	for idx := range chDescs {
 		chDesc := chDescs[idx]
-		ch, err := router.OpenChannel(chDesc, chDesc.MessageType, chDesc.RecvBufferCapacity)
+		ch, err := router.OpenChannel(chDesc)
 		if err != nil {
 			panic(fmt.Sprintf("failed to open channel %v: %v", chDesc.ID, err))
 		}
diff --git a/node/setup.go b/node/setup.go
index fb5599dfc9..fc611d9465 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -30,7 +30,6 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 	tmstrings "github.com/tendermint/tendermint/libs/strings"
-	protop2p "github.com/tendermint/tendermint/proto/tendermint/p2p"
 	"github.com/tendermint/tendermint/types"
 	"github.com/tendermint/tendermint/version"
 
@@ -485,7 +484,7 @@ func createPEXReactor(
 	router *p2p.Router,
 ) (service.Service, error) {
 
-	channel, err := router.OpenChannel(pex.ChannelDescriptor(), &protop2p.PexMessage{}, 128)
+	channel, err := router.OpenChannel(pex.ChannelDescriptor())
 	if err != nil {
 		return nil, err
 	}

From ca8f004112bc9567363c55b96ab8ee04d434ba70 Mon Sep 17 00:00:00 2001
From: Sam Kleinman <garen@tychoish.com>
Date: Fri, 15 Oct 2021 16:08:09 -0400
Subject: [PATCH 57/57] p2p: remove final shims from p2p package (#7136)

This is, perhaps, the trival final piece of #7075 that I've been
working on.

There's more work to be done:
- push more of the setup into the pacakges themselves
- move channel-based sending/filtering out of the
- simplify the buffering throuhgout the p2p stack.
---
 internal/blocksync/reactor.go       | 33 +++++-------
 internal/consensus/reactor.go       | 15 +++---
 internal/evidence/reactor.go        | 33 +++++-------
 internal/mempool/v0/reactor.go      | 25 ++++-----
 internal/mempool/v0/reactor_test.go |  2 +-
 internal/mempool/v1/reactor.go      | 25 ++++-----
 internal/mempool/v1/reactor_test.go |  2 +-
 internal/p2p/conn/connection.go     | 31 ++++++-----
 internal/statesync/reactor.go       | 81 ++++++++++++++---------------
 node/node.go                        | 37 ++++++-------
 node/setup.go                       | 54 +++++++++++++------
 11 files changed, 158 insertions(+), 180 deletions(-)

diff --git a/internal/blocksync/reactor.go b/internal/blocksync/reactor.go
index eebfda764e..43c3e83cd1 100644
--- a/internal/blocksync/reactor.go
+++ b/internal/blocksync/reactor.go
@@ -17,27 +17,7 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-var (
-	_ service.Service = (*Reactor)(nil)
-
-	// ChannelShims contains a map of ChannelDescriptorShim objects, where each
-	// object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding
-	// p2p proto.Message the new p2p Channel is responsible for handling.
-	//
-	//
-	// TODO: Remove once p2p refactor is complete.
-	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = []*p2p.ChannelDescriptor{
-		{
-			ID:                  BlockSyncChannel,
-			MessageType:         new(bcproto.Message),
-			Priority:            5,
-			SendQueueCapacity:   1000,
-			RecvBufferCapacity:  1024,
-			RecvMessageCapacity: MaxMsgSize,
-		},
-	}
-)
+var _ service.Service = (*Reactor)(nil)
 
 const (
 	// BlockSyncChannel is a channel for blocks and status updates
@@ -55,6 +35,17 @@ const (
 	syncTimeout = 60 * time.Second
 )
 
+func GetChannelDescriptor() *p2p.ChannelDescriptor {
+	return &p2p.ChannelDescriptor{
+		ID:                  BlockSyncChannel,
+		MessageType:         new(bcproto.Message),
+		Priority:            5,
+		SendQueueCapacity:   1000,
+		RecvBufferCapacity:  1024,
+		RecvMessageCapacity: MaxMsgSize,
+	}
+}
+
 type consensusReactor interface {
 	// For when we switch from block sync reactor to the consensus
 	// machine.
diff --git a/internal/consensus/reactor.go b/internal/consensus/reactor.go
index eb8345b727..62517fd4fe 100644
--- a/internal/consensus/reactor.go
+++ b/internal/consensus/reactor.go
@@ -21,15 +21,12 @@ import (
 var (
 	_ service.Service = (*Reactor)(nil)
 	_ p2p.Wrapper     = (*tmcons.Message)(nil)
+)
 
-	// ChannelShims contains a map of ChannelDescriptorShim objects, where each
-	// object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding
-	// p2p proto.Message the new p2p Channel is responsible for handling.
-	//
-	//
-	// TODO: Remove once p2p refactor is complete.
-	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = []*p2p.ChannelDescriptor{
+// GetChannelDescriptor produces an instance of a descriptor for this
+// package's required channels.
+func GetChannelDescriptors() []*p2p.ChannelDescriptor {
+	return []*p2p.ChannelDescriptor{
 		{
 			ID:                  StateChannel,
 			MessageType:         new(tmcons.Message),
@@ -66,7 +63,7 @@ var (
 			RecvMessageCapacity: maxMsgSize,
 		},
 	}
-)
+}
 
 const (
 	StateChannel       = p2p.ChannelID(0x20)
diff --git a/internal/evidence/reactor.go b/internal/evidence/reactor.go
index 6f96b39062..c2f25bd361 100644
--- a/internal/evidence/reactor.go
+++ b/internal/evidence/reactor.go
@@ -15,26 +15,7 @@ import (
 	"github.com/tendermint/tendermint/types"
 )
 
-var (
-	_ service.Service = (*Reactor)(nil)
-
-	// ChannelShims contains a map of ChannelDescriptorShim objects, where each
-	// object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding
-	// p2p proto.Message the new p2p Channel is responsible for handling.
-	//
-	//
-	// TODO: Remove once p2p refactor is complete.
-	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = []*p2p.ChannelDescriptor{
-		{
-			ID:                  EvidenceChannel,
-			MessageType:         new(tmproto.EvidenceList),
-			Priority:            6,
-			RecvMessageCapacity: maxMsgSize,
-			RecvBufferCapacity:  32,
-		},
-	}
-)
+var _ service.Service = (*Reactor)(nil)
 
 const (
 	EvidenceChannel = p2p.ChannelID(0x38)
@@ -48,6 +29,18 @@ const (
 	broadcastEvidenceIntervalS = 10
 )
 
+// GetChannelDescriptor produces an instance of a descriptor for this
+// package's required channels.
+func GetChannelDescriptor() *p2p.ChannelDescriptor {
+	return &p2p.ChannelDescriptor{
+		ID:                  EvidenceChannel,
+		MessageType:         new(tmproto.EvidenceList),
+		Priority:            6,
+		RecvMessageCapacity: maxMsgSize,
+		RecvBufferCapacity:  32,
+	}
+}
+
 // Reactor handles evpool evidence broadcasting amongst peers.
 type Reactor struct {
 	service.BaseService
diff --git a/internal/mempool/v0/reactor.go b/internal/mempool/v0/reactor.go
index d2a6218292..1183216457 100644
--- a/internal/mempool/v0/reactor.go
+++ b/internal/mempool/v0/reactor.go
@@ -83,14 +83,9 @@ func NewReactor(
 	return r
 }
 
-// GetChannelShims returns a map of ChannelDescriptorShim objects, where each
-// object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding
-// p2p proto.Message the new p2p Channel is responsible for handling.
-//
-//
-// TODO: Remove once p2p refactor is complete.
-// ref: https://github.com/tendermint/tendermint/issues/5670
-func GetChannelShims(cfg *config.MempoolConfig) []*p2p.ChannelDescriptor {
+// GetChannelDescriptor produces an instance of a descriptor for this
+// package's required channels.
+func GetChannelDescriptor(cfg *config.MempoolConfig) *p2p.ChannelDescriptor {
 	largestTx := make([]byte, cfg.MaxTxBytes)
 	batchMsg := protomem.Message{
 		Sum: &protomem.Message_Txs{
@@ -98,14 +93,12 @@ func GetChannelShims(cfg *config.MempoolConfig) []*p2p.ChannelDescriptor {
 		},
 	}
 
-	return []*p2p.ChannelDescriptor{
-		{
-			ID:                  mempool.MempoolChannel,
-			MessageType:         new(protomem.Message),
-			Priority:            5,
-			RecvMessageCapacity: batchMsg.Size(),
-			RecvBufferCapacity:  128,
-		},
+	return &p2p.ChannelDescriptor{
+		ID:                  mempool.MempoolChannel,
+		MessageType:         new(protomem.Message),
+		Priority:            5,
+		RecvMessageCapacity: batchMsg.Size(),
+		RecvBufferCapacity:  128,
 	}
 }
 
diff --git a/internal/mempool/v0/reactor_test.go b/internal/mempool/v0/reactor_test.go
index 104e1d4bd3..69582284b1 100644
--- a/internal/mempool/v0/reactor_test.go
+++ b/internal/mempool/v0/reactor_test.go
@@ -50,7 +50,7 @@ func setup(t *testing.T, config *config.MempoolConfig, numNodes int, chBuf uint)
 		peerUpdates:    make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := GetChannelShims(config)[0]
+	chDesc := GetChannelDescriptor(config)
 	chDesc.RecvBufferCapacity = int(chBuf)
 	rts.mempoolChnnels = rts.network.MakeChannelsNoCleanup(t, chDesc)
 
diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go
index e4b04c9319..8ef5a6bd89 100644
--- a/internal/mempool/v1/reactor.go
+++ b/internal/mempool/v1/reactor.go
@@ -90,14 +90,9 @@ func NewReactor(
 
 func defaultObservePanic(r interface{}) {}
 
-// GetChannelShims returns a map of ChannelDescriptorShim objects, where each
-// object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding
-// p2p proto.Message the new p2p Channel is responsible for handling.
-//
-//
-// TODO: Remove once p2p refactor is complete.
-// ref: https://github.com/tendermint/tendermint/issues/5670
-func GetChannelShims(cfg *config.MempoolConfig) []*p2p.ChannelDescriptor {
+// GetChannelDescriptor produces an instance of a descriptor for this
+// package's required channels.
+func GetChannelDescriptor(cfg *config.MempoolConfig) *p2p.ChannelDescriptor {
 	largestTx := make([]byte, cfg.MaxTxBytes)
 	batchMsg := protomem.Message{
 		Sum: &protomem.Message_Txs{
@@ -105,14 +100,12 @@ func GetChannelShims(cfg *config.MempoolConfig) []*p2p.ChannelDescriptor {
 		},
 	}
 
-	return []*p2p.ChannelDescriptor{
-		{
-			ID:                  mempool.MempoolChannel,
-			MessageType:         new(protomem.Message),
-			Priority:            5,
-			RecvMessageCapacity: batchMsg.Size(),
-			RecvBufferCapacity:  128,
-		},
+	return &p2p.ChannelDescriptor{
+		ID:                  mempool.MempoolChannel,
+		MessageType:         new(protomem.Message),
+		Priority:            5,
+		RecvMessageCapacity: batchMsg.Size(),
+		RecvBufferCapacity:  128,
 	}
 }
 
diff --git a/internal/mempool/v1/reactor_test.go b/internal/mempool/v1/reactor_test.go
index f004e75a9c..56e6057a1b 100644
--- a/internal/mempool/v1/reactor_test.go
+++ b/internal/mempool/v1/reactor_test.go
@@ -50,7 +50,7 @@ func setupReactors(t *testing.T, numNodes int, chBuf uint) *reactorTestSuite {
 		peerUpdates:     make(map[types.NodeID]*p2p.PeerUpdates, numNodes),
 	}
 
-	chDesc := GetChannelShims(cfg.Mempool)[0]
+	chDesc := GetChannelDescriptor(cfg.Mempool)
 	rts.mempoolChannels = rts.network.MakeChannelsNoCleanup(t, chDesc)
 
 	for nodeID := range rts.network.Nodes {
diff --git a/internal/p2p/conn/connection.go b/internal/p2p/conn/connection.go
index 1e149a2e53..a99e83dc51 100644
--- a/internal/p2p/conn/connection.go
+++ b/internal/p2p/conn/connection.go
@@ -81,8 +81,8 @@ type MConnection struct {
 	recvMonitor   *flow.Monitor
 	send          chan struct{}
 	pong          chan struct{}
-	channels      []*Channel
-	channelsIdx   map[ChannelID]*Channel
+	channels      []*channel
+	channelsIdx   map[ChannelID]*channel
 	onReceive     receiveCbFunc
 	onError       errorCbFunc
 	errored       uint32
@@ -186,8 +186,8 @@ func NewMConnectionWithConfig(
 	}
 
 	// Create channels
-	var channelsIdx = map[ChannelID]*Channel{}
-	var channels = []*Channel{}
+	var channelsIdx = map[ChannelID]*channel{}
+	var channels = []*channel{}
 
 	for _, desc := range chDescs {
 		channel := newChannel(mconn, *desc)
@@ -436,7 +436,7 @@ func (c *MConnection) sendPacketMsg() bool {
 	// Choose a channel to create a PacketMsg from.
 	// The chosen channel will be the one whose recentlySent/priority is the least.
 	var leastRatio float32 = math.MaxFloat32
-	var leastChannel *Channel
+	var leastChannel *channel
 	for _, channel := range c.channels {
 		// If nothing to send, skip this channel
 		if !channel.isSendPending() {
@@ -639,9 +639,8 @@ func (chDesc ChannelDescriptor) FillDefaults() (filled ChannelDescriptor) {
 	return
 }
 
-// TODO: lowercase.
 // NOTE: not goroutine-safe.
-type Channel struct {
+type channel struct {
 	// Exponential moving average.
 	// This field must be accessed atomically.
 	// It is first in the struct to ensure correct alignment.
@@ -660,12 +659,12 @@ type Channel struct {
 	Logger log.Logger
 }
 
-func newChannel(conn *MConnection, desc ChannelDescriptor) *Channel {
+func newChannel(conn *MConnection, desc ChannelDescriptor) *channel {
 	desc = desc.FillDefaults()
 	if desc.Priority <= 0 {
 		panic("Channel default priority must be a positive integer")
 	}
-	return &Channel{
+	return &channel{
 		conn:                    conn,
 		desc:                    desc,
 		sendQueue:               make(chan []byte, desc.SendQueueCapacity),
@@ -674,14 +673,14 @@ func newChannel(conn *MConnection, desc ChannelDescriptor) *Channel {
 	}
 }
 
-func (ch *Channel) SetLogger(l log.Logger) {
+func (ch *channel) SetLogger(l log.Logger) {
 	ch.Logger = l
 }
 
 // Queues message to send to this channel.
 // Goroutine-safe
 // Times out (and returns false) after defaultSendTimeout
-func (ch *Channel) sendBytes(bytes []byte) bool {
+func (ch *channel) sendBytes(bytes []byte) bool {
 	select {
 	case ch.sendQueue <- bytes:
 		atomic.AddInt32(&ch.sendQueueSize, 1)
@@ -694,7 +693,7 @@ func (ch *Channel) sendBytes(bytes []byte) bool {
 // Returns true if any PacketMsgs are pending to be sent.
 // Call before calling nextPacketMsg()
 // Goroutine-safe
-func (ch *Channel) isSendPending() bool {
+func (ch *channel) isSendPending() bool {
 	if len(ch.sending) == 0 {
 		if len(ch.sendQueue) == 0 {
 			return false
@@ -706,7 +705,7 @@ func (ch *Channel) isSendPending() bool {
 
 // Creates a new PacketMsg to send.
 // Not goroutine-safe
-func (ch *Channel) nextPacketMsg() tmp2p.PacketMsg {
+func (ch *channel) nextPacketMsg() tmp2p.PacketMsg {
 	packet := tmp2p.PacketMsg{ChannelID: int32(ch.desc.ID)}
 	maxSize := ch.maxPacketMsgPayloadSize
 	packet.Data = ch.sending[:tmmath.MinInt(maxSize, len(ch.sending))]
@@ -723,7 +722,7 @@ func (ch *Channel) nextPacketMsg() tmp2p.PacketMsg {
 
 // Writes next PacketMsg to w and updates c.recentlySent.
 // Not goroutine-safe
-func (ch *Channel) writePacketMsgTo(w io.Writer) (n int, err error) {
+func (ch *channel) writePacketMsgTo(w io.Writer) (n int, err error) {
 	packet := ch.nextPacketMsg()
 	n, err = protoio.NewDelimitedWriter(w).WriteMsg(mustWrapPacket(&packet))
 	atomic.AddInt64(&ch.recentlySent, int64(n))
@@ -733,7 +732,7 @@ func (ch *Channel) writePacketMsgTo(w io.Writer) (n int, err error) {
 // Handles incoming PacketMsgs. It returns a message bytes if message is
 // complete, which is owned by the caller and will not be modified.
 // Not goroutine-safe
-func (ch *Channel) recvPacketMsg(packet tmp2p.PacketMsg) ([]byte, error) {
+func (ch *channel) recvPacketMsg(packet tmp2p.PacketMsg) ([]byte, error) {
 	ch.Logger.Debug("Read PacketMsg", "conn", ch.conn, "packet", packet)
 	var recvCap, recvReceived = ch.desc.RecvMessageCapacity, len(ch.recving) + len(packet.Data)
 	if recvCap < recvReceived {
@@ -750,7 +749,7 @@ func (ch *Channel) recvPacketMsg(packet tmp2p.PacketMsg) ([]byte, error) {
 
 // Call this periodically to update stats for throttling purposes.
 // Not goroutine-safe
-func (ch *Channel) updateStats() {
+func (ch *channel) updateStats() {
 	// Exponential decay of stats.
 	// TODO: optimize.
 	atomic.StoreInt64(&ch.recentlySent, int64(float64(atomic.LoadInt64(&ch.recentlySent))*0.8))
diff --git a/internal/statesync/reactor.go b/internal/statesync/reactor.go
index 99cb4e6ab9..939fb409ce 100644
--- a/internal/statesync/reactor.go
+++ b/internal/statesync/reactor.go
@@ -28,48 +28,6 @@ import (
 var (
 	_ service.Service = (*Reactor)(nil)
 	_ p2p.Wrapper     = (*ssproto.Message)(nil)
-
-	// ChannelShims contains a map of ChannelDescriptorShim objects, where each
-	// object wraps a reference to a legacy p2p ChannelDescriptor and the corresponding
-	// p2p proto.Message the new p2p Channel is responsible for handling.
-	//
-	//
-	// TODO: Remove once p2p refactor is complete.
-	// ref: https://github.com/tendermint/tendermint/issues/5670
-	ChannelShims = []*p2p.ChannelDescriptor{
-		{
-			ID:                  SnapshotChannel,
-			MessageType:         new(ssproto.Message),
-			Priority:            6,
-			SendQueueCapacity:   10,
-			RecvMessageCapacity: snapshotMsgSize,
-			RecvBufferCapacity:  128,
-		},
-		{
-			ID:                  ChunkChannel,
-			Priority:            3,
-			MessageType:         new(ssproto.Message),
-			SendQueueCapacity:   4,
-			RecvMessageCapacity: chunkMsgSize,
-			RecvBufferCapacity:  128,
-		},
-		{
-			ID:                  LightBlockChannel,
-			MessageType:         new(ssproto.Message),
-			Priority:            5,
-			SendQueueCapacity:   10,
-			RecvMessageCapacity: lightBlockMsgSize,
-			RecvBufferCapacity:  128,
-		},
-		{
-			ID:                  ParamsChannel,
-			MessageType:         new(ssproto.Message),
-			Priority:            2,
-			SendQueueCapacity:   10,
-			RecvMessageCapacity: paramMsgSize,
-			RecvBufferCapacity:  128,
-		},
-	}
 )
 
 const (
@@ -113,6 +71,45 @@ const (
 	maxLightBlockRequestRetries = 20
 )
 
+func GetChannelDescriptors() []*p2p.ChannelDescriptor {
+	return []*p2p.ChannelDescriptor{
+		{
+
+			ID:                  SnapshotChannel,
+			MessageType:         new(ssproto.Message),
+			Priority:            6,
+			SendQueueCapacity:   10,
+			RecvMessageCapacity: snapshotMsgSize,
+			RecvBufferCapacity:  128,
+		},
+		{
+			ID:                  ChunkChannel,
+			Priority:            3,
+			MessageType:         new(ssproto.Message),
+			SendQueueCapacity:   4,
+			RecvMessageCapacity: chunkMsgSize,
+			RecvBufferCapacity:  128,
+		},
+		{
+			ID:                  LightBlockChannel,
+			MessageType:         new(ssproto.Message),
+			Priority:            5,
+			SendQueueCapacity:   10,
+			RecvMessageCapacity: lightBlockMsgSize,
+			RecvBufferCapacity:  128,
+		},
+		{
+			ID:                  ParamsChannel,
+			MessageType:         new(ssproto.Message),
+			Priority:            2,
+			SendQueueCapacity:   10,
+			RecvMessageCapacity: paramMsgSize,
+			RecvBufferCapacity:  128,
+		},
+	}
+
+}
+
 // Metricer defines an interface used for the rpc sync info query, please see statesync.metrics
 // for the details.
 type Metricer interface {
diff --git a/node/node.go b/node/node.go
index 0a48bf0b7a..727722279a 100644
--- a/node/node.go
+++ b/node/node.go
@@ -303,11 +303,14 @@ func makeNode(cfg *config.Config,
 		sm.BlockExecutorWithMetrics(nodeMetrics.state),
 	)
 
-	csReactor, csState := createConsensusReactor(
+	csReactor, csState, err := createConsensusReactor(
 		cfg, state, blockExec, blockStore, mp, evPool,
 		privValidator, nodeMetrics.consensus, stateSync || blockSync, eventBus,
 		peerManager, router, consensusLogger,
 	)
+	if err != nil {
+		return nil, combineCloseError(err, makeCloser(closers))
+	}
 
 	// Create the blockchain reactor. Note, we do not start block sync if we're
 	// doing a state sync first.
@@ -334,7 +337,17 @@ func makeNode(cfg *config.Config,
 	// we should clean this whole thing up. See:
 	// https://github.com/tendermint/tendermint/issues/4644
 	ssLogger := logger.With("module", "statesync")
-	channels := makeChannelsFromShims(router, statesync.ChannelShims)
+	ssChDesc := statesync.GetChannelDescriptors()
+	channels := make(map[p2p.ChannelID]*p2p.Channel, len(ssChDesc))
+	for idx := range ssChDesc {
+		chd := ssChDesc[idx]
+		ch, err := router.OpenChannel(chd)
+		if err != nil {
+			return nil, err
+		}
+
+		channels[ch.ID] = ch
+	}
 
 	peerUpdates := peerManager.Subscribe()
 	stateSyncReactor := statesync.NewReactor(
@@ -1088,23 +1101,3 @@ func getRouterConfig(conf *config.Config, proxyApp proxy.AppConns) p2p.RouterOpt
 
 	return opts
 }
-
-// FIXME: Temporary helper function, shims should be removed.
-func makeChannelsFromShims(
-	router *p2p.Router,
-	chDescs []*p2p.ChannelDescriptor,
-) map[p2p.ChannelID]*p2p.Channel {
-
-	channels := map[p2p.ChannelID]*p2p.Channel{}
-	for idx := range chDescs {
-		chDesc := chDescs[idx]
-		ch, err := router.OpenChannel(chDesc)
-		if err != nil {
-			panic(fmt.Sprintf("failed to open channel %v: %v", chDesc.ID, err))
-		}
-
-		channels[chDesc.ID] = ch
-	}
-
-	return channels
-}
diff --git a/node/setup.go b/node/setup.go
index fc611d9465..40ced410cc 100644
--- a/node/setup.go
+++ b/node/setup.go
@@ -198,13 +198,15 @@ func createMempoolReactor(
 ) (service.Service, mempool.Mempool, error) {
 
 	logger = logger.With("module", "mempool", "version", cfg.Mempool.Version)
-	channelShims := mempoolv0.GetChannelShims(cfg.Mempool)
-
-	channels := makeChannelsFromShims(router, channelShims)
 	peerUpdates := peerManager.Subscribe()
 
 	switch cfg.Mempool.Version {
 	case config.MempoolV0:
+		ch, err := router.OpenChannel(mempoolv0.GetChannelDescriptor(cfg.Mempool))
+		if err != nil {
+			return nil, nil, err
+		}
+
 		mp := mempoolv0.NewCListMempool(
 			cfg.Mempool,
 			proxyApp.Mempool(),
@@ -221,7 +223,7 @@ func createMempoolReactor(
 			cfg.Mempool,
 			peerManager,
 			mp,
-			channels[mempool.MempoolChannel],
+			ch,
 			peerUpdates,
 		)
 
@@ -232,6 +234,11 @@ func createMempoolReactor(
 		return reactor, mp, nil
 
 	case config.MempoolV1:
+		ch, err := router.OpenChannel(mempoolv1.GetChannelDescriptor(cfg.Mempool))
+		if err != nil {
+			return nil, nil, err
+		}
+
 		mp := mempoolv1.NewTxMempool(
 			logger,
 			cfg.Mempool,
@@ -247,7 +254,7 @@ func createMempoolReactor(
 			cfg.Mempool,
 			peerManager,
 			mp,
-			channels[mempool.MempoolChannel],
+			ch,
 			peerUpdates,
 		)
 
@@ -283,9 +290,14 @@ func createEvidenceReactor(
 		return nil, nil, fmt.Errorf("creating evidence pool: %w", err)
 	}
 
+	ch, err := router.OpenChannel(evidence.GetChannelDescriptor())
+	if err != nil {
+		return nil, nil, fmt.Errorf("creating evidence channel: %w", err)
+	}
+
 	evidenceReactor := evidence.NewReactor(
 		logger,
-		makeChannelsFromShims(router, evidence.ChannelShims)[evidence.EvidenceChannel],
+		ch,
 		peerManager.Subscribe(),
 		evidencePool,
 	)
@@ -307,12 +319,16 @@ func createBlockchainReactor(
 
 	logger = logger.With("module", "blockchain")
 
-	channels := makeChannelsFromShims(router, blocksync.ChannelShims)
+	ch, err := router.OpenChannel(blocksync.GetChannelDescriptor())
+	if err != nil {
+		return nil, err
+	}
+
 	peerUpdates := peerManager.Subscribe()
 
 	reactor, err := blocksync.NewReactor(
 		logger, state.Copy(), blockExec, blockStore, csReactor,
-		channels[blocksync.BlockSyncChannel], peerUpdates, blockSync,
+		ch, peerUpdates, blockSync,
 		metrics,
 	)
 	if err != nil {
@@ -336,7 +352,7 @@ func createConsensusReactor(
 	peerManager *p2p.PeerManager,
 	router *p2p.Router,
 	logger log.Logger,
-) (*consensus.Reactor, *consensus.State) {
+) (*consensus.Reactor, *consensus.State, error) {
 
 	consensusState := consensus.NewState(
 		cfg.Consensus,
@@ -352,13 +368,19 @@ func createConsensusReactor(
 		consensusState.SetPrivValidator(privValidator)
 	}
 
-	var (
-		channels    map[p2p.ChannelID]*p2p.Channel
-		peerUpdates *p2p.PeerUpdates
-	)
+	csChDesc := consensus.GetChannelDescriptors()
+	channels := make(map[p2p.ChannelID]*p2p.Channel, len(csChDesc))
+	for idx := range csChDesc {
+		chd := csChDesc[idx]
+		ch, err := router.OpenChannel(chd)
+		if err != nil {
+			return nil, nil, err
+		}
 
-	channels = makeChannelsFromShims(router, consensus.ChannelShims)
-	peerUpdates = peerManager.Subscribe()
+		channels[ch.ID] = ch
+	}
+
+	peerUpdates := peerManager.Subscribe()
 
 	reactor := consensus.NewReactor(
 		logger,
@@ -376,7 +398,7 @@ func createConsensusReactor(
 	// consensusReactor will set it on consensusState and blockExecutor.
 	reactor.SetEventBus(eventBus)
 
-	return reactor, consensusState
+	return reactor, consensusState, nil
 }
 
 func createTransport(logger log.Logger, cfg *config.Config) *p2p.MConnTransport {