nolint lll

abci/client/client.go

@@ -1,4 +1,4 @@
-package abciclient
+package abcicli
 
 import (
 	"context"

abci/client/creators.go

@@ -1,66 +0,0 @@
-package abciclient
-
-import (
-	"fmt"
-
-	"github.com/tendermint/tendermint/abci/types"
-	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-)
-
-//go:generate ../scripts/mockery_generate.sh Creator
-
-// Creator creates new ABCI clients.
-type Creator interface {
-	// NewClient returns a new ABCI client.
-	NewClient() (Client, error)
-}
-
-//----------------------------------------------------
-// local proxy uses a mutex on an in-proc app
-
-type localCreator struct {
-	mtx *tmsync.RWMutex
-	app types.Application
-}
-
-// NewLocalCreator returns a ClientCreator for the given app,
-// which will be running locally.
-func NewLocalCreator(app types.Application) Creator {
-	return &localCreator{
-		mtx: new(tmsync.RWMutex),
-		app: app,
-	}
-}
-
-func (l *localCreator) NewABCIClient() (Client, error) {
-	return NewLocalClient(l.mtx, l.app), nil
-}
-
-//---------------------------------------------------------------
-// remote proxy opens new connections to an external app process
-
-type remoteCreator struct {
-	addr        string
-	transport   string
-	mustConnect bool
-}
-
-// NewRemoteCreator returns a ClientCreator for the given address (e.g.
-// "192.168.0.1") and transport (e.g. "tcp"). Set mustConnect to true if you
-// want the client to connect before reporting success.
-func NewRemoteCreator(addr, transport string, mustConnect bool) Creator {
-	return &remoteCreator{
-		addr:        addr,
-		transport:   transport,
-		mustConnect: mustConnect,
-	}
-}
-
-func (r *remoteCreator) NewClient() (Client, error) {
-	remoteApp, err := NewClient(r.addr, r.transport, r.mustConnect)
-	if err != nil {
-		return nil, fmt.Errorf("failed to connect to proxy: %w", err)
-	}
-
-	return remoteApp, nil
-}

abci/client/doc.go

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

abci/client/grpc_client.go

@@ -1,4 +1,4 @@
-package abciclient
+package abcicli
 
 import (
 	"context"

abci/client/local_client.go

@@ -1,4 +1,4 @@
-package abciclient
+package abcicli
 
 import (
 	"context"

abci/client/mocks/client.go

@@ -5,7 +5,7 @@ package mocks
 import (
 	context "context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 
 	log "github.com/tendermint/tendermint/libs/log"
 
@@ -20,15 +20,15 @@ type Client struct {
 }
 
 // ApplySnapshotChunkAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) ApplySnapshotChunkAsync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*abciclient.ReqRes, error) {
+func (_m *Client) ApplySnapshotChunkAsync(_a0 context.Context, _a1 types.RequestApplySnapshotChunk) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestApplySnapshotChunk) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -66,15 +66,15 @@ func (_m *Client) ApplySnapshotChunkSync(_a0 context.Context, _a1 types.RequestA
 }
 
 // BeginBlockAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) BeginBlockAsync(_a0 context.Context, _a1 types.RequestBeginBlock) (*abciclient.ReqRes, error) {
+func (_m *Client) BeginBlockAsync(_a0 context.Context, _a1 types.RequestBeginBlock) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestBeginBlock) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -112,15 +112,15 @@ func (_m *Client) BeginBlockSync(_a0 context.Context, _a1 types.RequestBeginBloc
 }
 
 // CheckTxAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abciclient.ReqRes, error) {
+func (_m *Client) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -158,15 +158,15 @@ func (_m *Client) CheckTxSync(_a0 context.Context, _a1 types.RequestCheckTx) (*t
 }
 
 // CommitAsync provides a mock function with given fields: _a0
-func (_m *Client) CommitAsync(_a0 context.Context) (*abciclient.ReqRes, error) {
+func (_m *Client) CommitAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context) *abcicli.ReqRes); ok {
 		r0 = rf(_a0)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -204,15 +204,15 @@ func (_m *Client) CommitSync(_a0 context.Context) (*types.ResponseCommit, error)
 }
 
 // DeliverTxAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abciclient.ReqRes, error) {
+func (_m *Client) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -250,15 +250,15 @@ func (_m *Client) DeliverTxSync(_a0 context.Context, _a1 types.RequestDeliverTx)
 }
 
 // EchoAsync provides a mock function with given fields: ctx, msg
-func (_m *Client) EchoAsync(ctx context.Context, msg string) (*abciclient.ReqRes, error) {
+func (_m *Client) EchoAsync(ctx context.Context, msg string) (*abcicli.ReqRes, error) {
 	ret := _m.Called(ctx, msg)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, string) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, string) *abcicli.ReqRes); ok {
 		r0 = rf(ctx, msg)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -296,15 +296,15 @@ func (_m *Client) EchoSync(ctx context.Context, msg string) (*types.ResponseEcho
 }
 
 // EndBlockAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) EndBlockAsync(_a0 context.Context, _a1 types.RequestEndBlock) (*abciclient.ReqRes, error) {
+func (_m *Client) EndBlockAsync(_a0 context.Context, _a1 types.RequestEndBlock) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestEndBlock) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -356,15 +356,15 @@ func (_m *Client) Error() error {
 }
 
 // FlushAsync provides a mock function with given fields: _a0
-func (_m *Client) FlushAsync(_a0 context.Context) (*abciclient.ReqRes, error) {
+func (_m *Client) FlushAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context) *abcicli.ReqRes); ok {
 		r0 = rf(_a0)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -393,15 +393,15 @@ func (_m *Client) FlushSync(_a0 context.Context) error {
 }
 
 // InfoAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) InfoAsync(_a0 context.Context, _a1 types.RequestInfo) (*abciclient.ReqRes, error) {
+func (_m *Client) InfoAsync(_a0 context.Context, _a1 types.RequestInfo) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInfo) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -439,15 +439,15 @@ func (_m *Client) InfoSync(_a0 context.Context, _a1 types.RequestInfo) (*types.R
 }
 
 // InitChainAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) InitChainAsync(_a0 context.Context, _a1 types.RequestInitChain) (*abciclient.ReqRes, error) {
+func (_m *Client) InitChainAsync(_a0 context.Context, _a1 types.RequestInitChain) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestInitChain) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -499,15 +499,15 @@ func (_m *Client) IsRunning() bool {
 }
 
 // ListSnapshotsAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) ListSnapshotsAsync(_a0 context.Context, _a1 types.RequestListSnapshots) (*abciclient.ReqRes, error) {
+func (_m *Client) ListSnapshotsAsync(_a0 context.Context, _a1 types.RequestListSnapshots) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestListSnapshots) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -545,15 +545,15 @@ func (_m *Client) ListSnapshotsSync(_a0 context.Context, _a1 types.RequestListSn
 }
 
 // LoadSnapshotChunkAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) LoadSnapshotChunkAsync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*abciclient.ReqRes, error) {
+func (_m *Client) LoadSnapshotChunkAsync(_a0 context.Context, _a1 types.RequestLoadSnapshotChunk) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestLoadSnapshotChunk) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -591,15 +591,15 @@ func (_m *Client) LoadSnapshotChunkSync(_a0 context.Context, _a1 types.RequestLo
 }
 
 // OfferSnapshotAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) OfferSnapshotAsync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*abciclient.ReqRes, error) {
+func (_m *Client) OfferSnapshotAsync(_a0 context.Context, _a1 types.RequestOfferSnapshot) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestOfferSnapshot) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -670,15 +670,15 @@ func (_m *Client) OnStop() {
 }
 
 // QueryAsync provides a mock function with given fields: _a0, _a1
-func (_m *Client) QueryAsync(_a0 context.Context, _a1 types.RequestQuery) (*abciclient.ReqRes, error) {
+func (_m *Client) QueryAsync(_a0 context.Context, _a1 types.RequestQuery) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestQuery) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -751,7 +751,7 @@ func (_m *Client) SetLogger(_a0 log.Logger) {
 }
 
 // SetResponseCallback provides a mock function with given fields: _a0
-func (_m *Client) SetResponseCallback(_a0 abciclient.Callback) {
+func (_m *Client) SetResponseCallback(_a0 abcicli.Callback) {
 	_m.Called(_a0)
 }
 

abci/client/socket_client.go

@@ -1,4 +1,4 @@
-package abciclient
+package abcicli
 
 import (
 	"bufio"

abci/client/socket_client_test.go

@@ -1,4 +1,4 @@
-package abciclient_test
+package abcicli_test
 
 import (
 	"context"
@@ -11,7 +11,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/server"
 	"github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/libs/service"
@@ -100,7 +100,7 @@ func TestHangingSyncCalls(t *testing.T) {
 }
 
 func setupClientServer(t *testing.T, app types.Application) (
-	service.Service, abciclient.Client) {
+	service.Service, abcicli.Client) {
 	// some port between 20k and 30k
 	port := 20000 + rand.Int31()%10000
 	addr := fmt.Sprintf("localhost:%d", port)
@@ -110,7 +110,7 @@ func setupClientServer(t *testing.T, app types.Application) (
 	err = s.Start()
 	require.NoError(t, err)
 
-	c := abciclient.NewSocketClient(addr, true)
+	c := abcicli.NewSocketClient(addr, true)
 	err = c.Start()
 	require.NoError(t, err)
 

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

@@ -15,7 +15,7 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmos "github.com/tendermint/tendermint/libs/os"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/abci/server"
@@ -27,7 +27,7 @@ import (
 
 // client is a global variable so it can be reused by the console
 var (
-	client abciclient.Client
+	client abcicli.Client
 	logger log.Logger
 
 	ctx = context.Background()
@@ -67,7 +67,7 @@ var RootCmd = &cobra.Command{
 
 		if client == nil {
 			var err error
-			client, err = abciclient.NewClient(flagAddress, flagAbci, false)
+			client, err = abcicli.NewClient(flagAddress, flagAbci, false)
 			if err != nil {
 				return err
 			}

abci/example/example_test.go

@@ -17,7 +17,7 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abciserver "github.com/tendermint/tendermint/abci/server"
@@ -61,7 +61,7 @@ func testStream(t *testing.T, app types.Application) {
 	})
 
 	// Connect to the socket
-	client := abciclient.NewSocketClient(socket, false)
+	client := abcicli.NewSocketClient(socket, false)
 	client.SetLogger(log.TestingLogger().With("module", "abci-client"))
 	err = client.Start()
 	require.NoError(t, err)

abci/example/kvstore/kvstore_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
 	abciserver "github.com/tendermint/tendermint/abci/server"
 	"github.com/tendermint/tendermint/abci/types"
@@ -229,7 +229,7 @@ func valsEqual(t *testing.T, vals1, vals2 []types.ValidatorUpdate) {
 	}
 }
 
-func makeSocketClientServer(app types.Application, name string) (abciclient.Client, service.Service, error) {
+func makeSocketClientServer(app types.Application, name string) (abcicli.Client, service.Service, error) {
 	// Start the listener
 	socket := fmt.Sprintf("unix://%s.sock", name)
 	logger := log.TestingLogger()
@@ -241,7 +241,7 @@ func makeSocketClientServer(app types.Application, name string) (abciclient.Clie
 	}
 
 	// Connect to the socket
-	client := abciclient.NewSocketClient(socket, false)
+	client := abcicli.NewSocketClient(socket, false)
 	client.SetLogger(logger.With("module", "abci-client"))
 	if err := client.Start(); err != nil {
 		if err = server.Stop(); err != nil {
@@ -253,7 +253,7 @@ func makeSocketClientServer(app types.Application, name string) (abciclient.Clie
 	return client, server, nil
 }
 
-func makeGRPCClientServer(app types.Application, name string) (abciclient.Client, service.Service, error) {
+func makeGRPCClientServer(app types.Application, name string) (abcicli.Client, service.Service, error) {
 	// Start the listener
 	socket := fmt.Sprintf("unix://%s.sock", name)
 	logger := log.TestingLogger()
@@ -265,7 +265,7 @@ func makeGRPCClientServer(app types.Application, name string) (abciclient.Client
 		return nil, nil, err
 	}
 
-	client := abciclient.NewGRPCClient(socket, true)
+	client := abcicli.NewGRPCClient(socket, true)
 	client.SetLogger(logger.With("module", "abci-client"))
 	if err := client.Start(); err != nil {
 		if err := server.Stop(); err != nil {
@@ -313,7 +313,7 @@ func TestClientServer(t *testing.T) {
 	runClientTests(t, gclient)
 }
 
-func runClientTests(t *testing.T, client abciclient.Client) {
+func runClientTests(t *testing.T, client abcicli.Client) {
 	// run some tests....
 	key := testKey
 	value := key
@@ -325,7 +325,7 @@ func runClientTests(t *testing.T, client abciclient.Client) {
 	testClient(t, client, tx, key, value)
 }
 
-func testClient(t *testing.T, app abciclient.Client, tx []byte, key, value string) {
+func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string) {
 	ar, err := app.DeliverTxSync(ctx, types.RequestDeliverTx{Tx: tx})
 	require.NoError(t, err)
 	require.False(t, ar.IsErr(), ar)

abci/tests/client_server_test.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	abciclientent "github.com/tendermint/tendermint/abci/client"
+	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abciserver "github.com/tendermint/tendermint/abci/server"
 )
@@ -20,7 +20,7 @@ func TestClientServerNoAddrPrefix(t *testing.T) {
 	err = server.Start()
 	assert.NoError(t, err, "expected no error on server.Start")
 
-	client, err := abciclientent.NewClient(addr, transport, true)
+	client, err := abciclient.NewClient(addr, transport, true)
 	assert.NoError(t, err, "expected no error on NewClient")
 	err = client.Start()
 	assert.NoError(t, err, "expected no error on client.Start")

abci/tests/server/client.go

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

abci/types/client.go

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

docs/tutorials/go-built-in.md

@@ -430,7 +430,7 @@ func newTendermint(app abci.Application, configFile string) (*nm.Node, error) {
   config,
   pv,
   nodeKey,
-  abcicli.NewLocalClientCreator(app),
+  proxy.NewLocalClientCreator(app),
   nm.DefaultGenesisDocProviderFunc(config),
   nm.DefaultDBProvider,
   nm.DefaultMetricsProvider(config.Instrumentation),
@@ -482,7 +482,7 @@ node, err := nm.NewNode(
  config,
  pv,
  nodeKey,
- abcicli.NewLocalClientCreator(app),
+ proxy.NewLocalClientCreator(app),
  nm.DefaultGenesisDocProviderFunc(config),
  nm.DefaultDBProvider,
  nm.DefaultMetricsProvider(config.Instrumentation),
@@ -495,7 +495,7 @@ if err != nil {
 `NewNode` requires a few things including a configuration file, a private
 validator, a node key and a few others in order to construct the full node.
 
-Note we use `abcicli.NewLocalClientCreator` here to create a local client instead
+Note we use `proxy.NewLocalClientCreator` here to create a local client instead
 of one communicating through a socket or gRPC.
 
 [viper](https://github.com/spf13/viper) is being used for reading the config,

go.mod

@@ -34,7 +34,7 @@ require (
 	github.com/spf13/viper v1.8.1
 	github.com/stretchr/testify v1.7.0
 	github.com/tendermint/tm-db v0.6.4
-	github.com/vektra/mockery/v2 v2.9.4
+	github.com/vektra/mockery/v2 v2.9.3
 	golang.org/x/crypto v0.0.0-20210513164829-c07d793c2f9a
 	golang.org/x/net v0.0.0-20210428140749-89ef3d95e781
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c

go.sum

@@ -895,8 +895,8 @@ github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyC
 github.com/valyala/fasthttp v1.16.0/go.mod h1:YOKImeEosDdBPnxc0gy7INqi3m1zK6A+xl6TwOBhHCA=
 github.com/valyala/quicktemplate v1.6.3/go.mod h1:fwPzK2fHuYEODzJ9pkw0ipCPNHZ2tD5KW4lOuSdPKzY=
 github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
-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/vektra/mockery/v2 v2.9.3 h1:ma6hcGQw4q/lhFUTJ+E9V8/5tsIcht9i2Q4d1qo26SQ=
+github.com/vektra/mockery/v2 v2.9.3/go.mod h1:2gU4Cf/f8YyC8oEaSXfCnZBMxMjMl/Ko205rlP0fO90=
 github.com/viki-org/dnscache v0.0.0-20130720023526-c70c1f23c5d8/go.mod h1:dniwbG03GafCjFohMDmz6Zc6oCuiqgH6tGNyXTkHzXE=
 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=

internal/blocksync/v0/reactor_test.go

@@ -7,17 +7,16 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	cons "github.com/tendermint/tendermint/internal/consensus"
 	"github.com/tendermint/tendermint/internal/mempool/mock"
 	"github.com/tendermint/tendermint/internal/p2p"
 	"github.com/tendermint/tendermint/internal/p2p/p2ptest"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/store"
@@ -98,7 +97,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(proxy.NewLocalClientCreator(&abci.BaseApplication{}))
 	require.NoError(t, rts.app[nodeID].Start())
 
 	blockDB := dbm.NewMemDB()

internal/blocksync/v2/reactor_test.go

@@ -13,7 +13,6 @@ import (
 	"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"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior"
@@ -21,11 +20,11 @@ import (
 	"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"
 	"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/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	sf "github.com/tendermint/tendermint/state/test/factory"
 	tmstore "github.com/tendermint/tendermint/store"
@@ -164,7 +163,7 @@ func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
 		appl = &mockBlockApplier{}
 	} else {
 		app := &testApp{}
-		cc := abciclient.NewLocalCreator(app)
+		cc := proxy.NewLocalClientCreator(app)
 		proxyApp := proxy.NewAppConns(cc)
 		err := proxyApp.Start()
 		require.NoError(t, err)
@@ -188,176 +187,176 @@ func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor {
 // 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)
+// 	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,
-//	}
+// 	params := testReactorParams{
+// 		logger:      log.TestingLogger(),
+// 		genDoc:      genDoc,
+// 		privVals:    privVals,
+// 		startHeight: 10,
+// 		bufferSize:  100,
+// 		mockA:       true,
+// 	}
 
-//	type testEvent struct {
-//		evType string
-//		peer   string
-//		height int64
-//	}
+// 	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"},
-//			},
-//		},
-//	}
+// 	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 _, 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)
-//			}
+// 			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()
-//		})
-//	}
+// 			// 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) {
@@ -483,7 +482,7 @@ func newReactorStore(
 
 	require.Len(t, privVals, 1)
 	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	if err != nil {

internal/consensus/byzantine_test.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/internal/evidence"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
@@ -52,7 +52,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 			thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 			defer os.RemoveAll(thisConfig.RootDir)
 
-			ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
+			ensureDir(t, path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
 			app := appFunc()
 			vals := types.TM2PB.ValidatorUpdates(state.Validators)
 			app.InitChain(abci.RequestInitChain{Validators: vals})
@@ -62,8 +62,8 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 
 			// one for mempool, one for consensus
 			mtx := new(tmsync.RWMutex)
-			proxyAppConnMem := abciclient.NewLocalClient(mtx, app)
-			proxyAppConnCon := abciclient.NewLocalClient(mtx, app)
+			proxyAppConnMem := abcicli.NewLocalClient(mtx, app)
+			proxyAppConnCon := abcicli.NewLocalClient(mtx, app)
 
 			// Make Mempool
 			mempool := mempoolv0.NewCListMempool(thisConfig.Mempool, proxyAppConnMem, 0)

internal/consensus/common_test.go

@@ -18,7 +18,7 @@ import (
 
 	dbm "github.com/tendermint/tm-db"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
@@ -69,9 +69,10 @@ func configSetup(t *testing.T) *cfg.Config {
 	return config
 }
 
-func ensureDir(dir string, mode os.FileMode) {
+func ensureDir(t *testing.T, dir string, mode os.FileMode) {
+	t.Helper()
 	if err := tmos.EnsureDir(dir, mode); err != nil {
-		panic(err)
+		t.Fatalf("error opening directory: %s", err)
 	}
 }
 
@@ -221,18 +222,20 @@ func startTestRound(cs *State, height int64, round int32) {
 
 // Create proposal block from cs1 but sign it with vs.
 func decideProposal(
+	t *testing.T,
 	cs1 *State,
 	vs *validatorStub,
 	height int64,
 	round int32,
 ) (proposal *types.Proposal, block *types.Block) {
+	t.Helper()
 	cs1.mtx.Lock()
 	block, blockParts := cs1.createProposalBlock()
 	validRound := cs1.ValidRound
 	chainID := cs1.state.ChainID
 	cs1.mtx.Unlock()
 	if block == nil {
-		panic("Failed to createProposalBlock. Did you forget to add commit for previous block?")
+		t.Fatal("Failed to createProposalBlock. Did you forget to add commit for previous block?")
 	}
 
 	// Make proposal
@@ -240,7 +243,7 @@ func decideProposal(
 	proposal = types.NewProposal(height, round, polRound, propBlockID)
 	p := proposal.ToProto()
 	if err := vs.SignProposal(context.Background(), chainID, p); err != nil {
-		panic(err)
+		t.Fatalf("error signing proposal: %s", err)
 	}
 
 	proposal.Signature = p.Signature
@@ -267,36 +270,38 @@ func signAddVotes(
 }
 
 func validatePrevote(t *testing.T, cs *State, round int32, privVal *validatorStub, blockHash []byte) {
+	t.Helper()
 	prevotes := cs.Votes.Prevotes(round)
 	pubKey, err := privVal.GetPubKey(context.Background())
 	require.NoError(t, err)
 	address := pubKey.Address()
 	var vote *types.Vote
 	if vote = prevotes.GetByAddress(address); vote == nil {
-		panic("Failed to find prevote from validator")
+		t.Fatalf("Failed to find prevote from validator")
 	}
 	if blockHash == nil {
 		if vote.BlockID.Hash != nil {
-			panic(fmt.Sprintf("Expected prevote to be for nil, got %X", vote.BlockID.Hash))
+			t.Fatalf("Expected prevote to be for nil, got %X", vote.BlockID.Hash)
 		}
 	} else {
 		if !bytes.Equal(vote.BlockID.Hash, blockHash) {
-			panic(fmt.Sprintf("Expected prevote to be for %X, got %X", blockHash, vote.BlockID.Hash))
+			t.Fatalf("Expected prevote to be for %X, got %X", blockHash, vote.BlockID.Hash)
 		}
 	}
 }
 
 func validateLastPrecommit(t *testing.T, cs *State, privVal *validatorStub, blockHash []byte) {
+	t.Helper()
 	votes := cs.LastCommit
 	pv, err := privVal.GetPubKey(context.Background())
 	require.NoError(t, err)
 	address := pv.Address()
 	var vote *types.Vote
 	if vote = votes.GetByAddress(address); vote == nil {
-		panic("Failed to find precommit from validator")
+		t.Fatalf("Failed to find precommit from validator")
 	}
 	if !bytes.Equal(vote.BlockID.Hash, blockHash) {
-		panic(fmt.Sprintf("Expected precommit to be for %X, got %X", blockHash, vote.BlockID.Hash))
+		t.Fatalf("Expected precommit to be for %X, got %X", blockHash, vote.BlockID.Hash)
 	}
 }
 
@@ -309,41 +314,42 @@ func validatePrecommit(
 	votedBlockHash,
 	lockedBlockHash []byte,
 ) {
+	t.Helper()
 	precommits := cs.Votes.Precommits(thisRound)
 	pv, err := privVal.GetPubKey(context.Background())
 	require.NoError(t, err)
 	address := pv.Address()
 	var vote *types.Vote
 	if vote = precommits.GetByAddress(address); vote == nil {
-		panic("Failed to find precommit from validator")
+		t.Fatalf("Failed to find precommit from validator")
 	}
 
 	if votedBlockHash == nil {
 		if vote.BlockID.Hash != nil {
-			panic("Expected precommit to be for nil")
+			t.Fatalf("Expected precommit to be for nil")
 		}
 	} else {
 		if !bytes.Equal(vote.BlockID.Hash, votedBlockHash) {
-			panic("Expected precommit to be for proposal block")
+			t.Fatalf("Expected precommit to be for proposal block")
 		}
 	}
 
 	if lockedBlockHash == nil {
 		if cs.LockedRound != lockRound || cs.LockedBlock != nil {
-			panic(fmt.Sprintf(
+			t.Fatalf(
 				"Expected to be locked on nil at round %d. Got locked at round %d with block %v",
 				lockRound,
 				cs.LockedRound,
-				cs.LockedBlock))
+				cs.LockedBlock)
 		}
 	} else {
 		if cs.LockedRound != lockRound || !bytes.Equal(cs.LockedBlock.Hash(), lockedBlockHash) {
-			panic(fmt.Sprintf(
+			t.Fatalf(
 				"Expected block to be locked on round %d, got %d. Got locked block %X, expected %X",
 				lockRound,
 				cs.LockedRound,
 				cs.LockedBlock.Hash(),
-				lockedBlockHash))
+				lockedBlockHash)
 		}
 	}
 }
@@ -357,6 +363,7 @@ func validatePrevoteAndPrecommit(
 	votedBlockHash,
 	lockedBlockHash []byte,
 ) {
+	t.Helper()
 	// verify the prevote
 	validatePrevote(t, cs, thisRound, privVal, votedBlockHash)
 	// verify precommit
@@ -410,8 +417,8 @@ func newStateWithConfigAndBlockStore(
 ) *State {
 	// one for mempool, one for consensus
 	mtx := new(tmsync.RWMutex)
-	proxyAppConnMem := abciclient.NewLocalClient(mtx, app)
-	proxyAppConnCon := abciclient.NewLocalClient(mtx, app)
+	proxyAppConnMem := abcicli.NewLocalClient(mtx, app)
+	proxyAppConnCon := abcicli.NewLocalClient(mtx, app)
 
 	// Make Mempool
 	mempool := mempoolv0.NewCListMempool(thisConfig.Mempool, proxyAppConnMem, 0)
@@ -444,13 +451,14 @@ func newStateWithConfigAndBlockStore(
 	return cs
 }
 
-func loadPrivValidator(config *cfg.Config) *privval.FilePV {
+func loadPrivValidator(t *testing.T, config *cfg.Config) *privval.FilePV {
+	t.Helper()
 	privValidatorKeyFile := config.PrivValidator.KeyFile()
-	ensureDir(filepath.Dir(privValidatorKeyFile), 0700)
+	ensureDir(t, filepath.Dir(privValidatorKeyFile), 0700)
 	privValidatorStateFile := config.PrivValidator.StateFile()
 	privValidator, err := privval.LoadOrGenFilePV(privValidatorKeyFile, privValidatorStateFile)
 	if err != nil {
-		panic(err)
+		t.Fatalf("error generating validator file: %s", err)
 	}
 	privValidator.Reset()
 	return privValidator
@@ -475,220 +483,241 @@ func randState(config *cfg.Config, nValidators int) (*State, []*validatorStub) {
 
 //-------------------------------------------------------------------------------
 
-func ensureNoNewEvent(ch <-chan tmpubsub.Message, timeout time.Duration,
+func ensureNoNewEvent(t *testing.T, ch <-chan tmpubsub.Message, timeout time.Duration,
 	errorMessage string) {
+	t.Helper()
 	select {
 	case <-time.After(timeout):
 		break
 	case <-ch:
-		panic(errorMessage)
+		t.Fatalf("unexpected event: %s", errorMessage)
 	}
 }
 
-func ensureNoNewEventOnChannel(ch <-chan tmpubsub.Message) {
+func ensureNoNewEventOnChannel(t *testing.T, ch <-chan tmpubsub.Message) {
+	t.Helper()
 	ensureNoNewEvent(
+		t,
 		ch,
 		ensureTimeout,
 		"We should be stuck waiting, not receiving new event on the channel")
 }
 
-func ensureNoNewRoundStep(stepCh <-chan tmpubsub.Message) {
+func ensureNoNewRoundStep(t *testing.T, stepCh <-chan tmpubsub.Message) {
+	t.Helper()
 	ensureNoNewEvent(
+		t,
 		stepCh,
 		ensureTimeout,
 		"We should be stuck waiting, not receiving NewRoundStep event")
 }
 
-func ensureNoNewUnlock(unlockCh <-chan tmpubsub.Message) {
+func ensureNoNewUnlock(t *testing.T, unlockCh <-chan tmpubsub.Message) {
+	t.Helper()
 	ensureNoNewEvent(
+		t,
 		unlockCh,
 		ensureTimeout,
 		"We should be stuck waiting, not receiving Unlock event")
 }
 
-func ensureNoNewTimeout(stepCh <-chan tmpubsub.Message, timeout int64) {
+func ensureNoNewTimeout(t *testing.T, stepCh <-chan tmpubsub.Message, timeout int64) {
+	t.Helper()
 	timeoutDuration := time.Duration(timeout*10) * time.Nanosecond
 	ensureNoNewEvent(
+		t,
 		stepCh,
 		timeoutDuration,
 		"We should be stuck waiting, not receiving NewTimeout event")
 }
 
-func ensureNewEvent(ch <-chan tmpubsub.Message, height int64, round int32, timeout time.Duration, errorMessage string) {
+func ensureNewEvent(t *testing.T, ch <-chan tmpubsub.Message, height int64, round int32, timeout time.Duration, errorMessage string) { //nolint: lll
+	t.Helper()
 	select {
 	case <-time.After(timeout):
-		panic(errorMessage)
+		t.Fatalf("timed out waiting for new event: %s", errorMessage)
 	case msg := <-ch:
 		roundStateEvent, ok := msg.Data().(types.EventDataRoundState)
 		if !ok {
-			panic(fmt.Sprintf("expected a EventDataRoundState, got %T. Wrong subscription channel?",
-				msg.Data()))
+			t.Fatalf("expected a EventDataRoundState, got %T. Wrong subscription channel?", msg.Data())
 		}
 		if roundStateEvent.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, roundStateEvent.Height))
+			t.Fatalf("expected height %v, got %v", height, roundStateEvent.Height)
 		}
 		if roundStateEvent.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, roundStateEvent.Round))
+			t.Fatalf("expected round %v, got %v", round, roundStateEvent.Round)
 		}
 		// TODO: We could check also for a step at this point!
 	}
 }
 
-func ensureNewRound(roundCh <-chan tmpubsub.Message, height int64, round int32) {
+func ensureNewRound(t *testing.T, roundCh <-chan tmpubsub.Message, height int64, round int32) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewRound event")
+		t.Fatal("Timeout expired while waiting for NewRound event")
 	case msg := <-roundCh:
 		newRoundEvent, ok := msg.Data().(types.EventDataNewRound)
 		if !ok {
-			panic(fmt.Sprintf("expected a EventDataNewRound, got %T. Wrong subscription channel?",
-				msg.Data()))
+			t.Fatalf("expected a EventDataNewRound, got %T. Wrong subscription channel?", msg.Data())
 		}
 		if newRoundEvent.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, newRoundEvent.Height))
+			t.Fatalf("expected height %v, got %v", height, newRoundEvent.Height)
 		}
 		if newRoundEvent.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, newRoundEvent.Round))
+			t.Fatalf("expected round %v, got %v", round, newRoundEvent.Round)
 		}
 	}
 }
 
-func ensureNewTimeout(timeoutCh <-chan tmpubsub.Message, height int64, round int32, timeout int64) {
+func ensureNewTimeout(t *testing.T, timeoutCh <-chan tmpubsub.Message, height int64, round int32, timeout int64) {
+	t.Helper()
 	timeoutDuration := time.Duration(timeout*10) * time.Nanosecond
-	ensureNewEvent(timeoutCh, height, round, timeoutDuration,
+	ensureNewEvent(t, timeoutCh, height, round, timeoutDuration,
 		"Timeout expired while waiting for NewTimeout event")
 }
 
-func ensureNewProposal(proposalCh <-chan tmpubsub.Message, height int64, round int32) {
+func ensureNewProposal(t *testing.T, proposalCh <-chan tmpubsub.Message, height int64, round int32) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewProposal event")
+		t.Fatalf("Timeout expired while waiting for NewProposal event")
 	case msg := <-proposalCh:
 		proposalEvent, ok := msg.Data().(types.EventDataCompleteProposal)
 		if !ok {
-			panic(fmt.Sprintf("expected a EventDataCompleteProposal, got %T. Wrong subscription channel?",
-				msg.Data()))
+			t.Fatalf("expected a EventDataCompleteProposal, got %T. Wrong subscription channel?",
+				msg.Data())
 		}
 		if proposalEvent.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, proposalEvent.Height))
+			t.Fatalf("expected height %v, got %v", height, proposalEvent.Height)
 		}
 		if proposalEvent.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, proposalEvent.Round))
+			t.Fatalf("expected round %v, got %v", round, proposalEvent.Round)
 		}
 	}
 }
 
-func ensureNewValidBlock(validBlockCh <-chan tmpubsub.Message, height int64, round int32) {
-	ensureNewEvent(validBlockCh, height, round, ensureTimeout,
+func ensureNewValidBlock(t *testing.T, validBlockCh <-chan tmpubsub.Message, height int64, round int32) {
+	t.Helper()
+	ensureNewEvent(t, validBlockCh, height, round, ensureTimeout,
 		"Timeout expired while waiting for NewValidBlock event")
 }
 
-func ensureNewBlock(blockCh <-chan tmpubsub.Message, height int64) {
+func ensureNewBlock(t *testing.T, blockCh <-chan tmpubsub.Message, height int64) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewBlock event")
+		t.Fatalf("Timeout expired while waiting for NewBlock event")
 	case msg := <-blockCh:
 		blockEvent, ok := msg.Data().(types.EventDataNewBlock)
 		if !ok {
-			panic(fmt.Sprintf("expected a EventDataNewBlock, got %T. Wrong subscription channel?",
-				msg.Data()))
+			t.Fatalf("expected a EventDataNewBlock, got %T. Wrong subscription channel?",
+				msg.Data())
 		}
 		if blockEvent.Block.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, blockEvent.Block.Height))
+			t.Fatalf("expected height %v, got %v", height, blockEvent.Block.Height)
 		}
 	}
 }
 
-func ensureNewBlockHeader(blockCh <-chan tmpubsub.Message, height int64, blockHash tmbytes.HexBytes) {
+func ensureNewBlockHeader(t *testing.T, blockCh <-chan tmpubsub.Message, height int64, blockHash tmbytes.HexBytes) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewBlockHeader event")
+		t.Fatalf("Timeout expired while waiting for NewBlockHeader event")
 	case msg := <-blockCh:
 		blockHeaderEvent, ok := msg.Data().(types.EventDataNewBlockHeader)
 		if !ok {
-			panic(fmt.Sprintf("expected a EventDataNewBlockHeader, got %T. Wrong subscription channel?",
-				msg.Data()))
+			t.Fatalf("expected a EventDataNewBlockHeader, got %T. Wrong subscription channel?",
+				msg.Data())
 		}
 		if blockHeaderEvent.Header.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, blockHeaderEvent.Header.Height))
+			t.Fatalf("expected height %v, got %v", height, blockHeaderEvent.Header.Height)
 		}
 		if !bytes.Equal(blockHeaderEvent.Header.Hash(), blockHash) {
-			panic(fmt.Sprintf("expected header %X, got %X", blockHash, blockHeaderEvent.Header.Hash()))
+			t.Fatalf("expected header %X, got %X", blockHash, blockHeaderEvent.Header.Hash())
 		}
 	}
 }
 
-func ensureNewUnlock(unlockCh <-chan tmpubsub.Message, height int64, round int32) {
-	ensureNewEvent(unlockCh, height, round, ensureTimeout,
+func ensureNewUnlock(t *testing.T, unlockCh <-chan tmpubsub.Message, height int64, round int32) {
+	t.Helper()
+	ensureNewEvent(t, unlockCh, height, round, ensureTimeout,
 		"Timeout expired while waiting for NewUnlock event")
 }
 
-func ensureProposal(proposalCh <-chan tmpubsub.Message, height int64, round int32, propID types.BlockID) {
+func ensureProposal(t *testing.T, proposalCh <-chan tmpubsub.Message, height int64, round int32, propID types.BlockID) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewProposal event")
+		t.Fatalf("Timeout expired while waiting for NewProposal event")
 	case msg := <-proposalCh:
 		proposalEvent, ok := msg.Data().(types.EventDataCompleteProposal)
 		if !ok {
-			panic(fmt.Sprintf("expected a EventDataCompleteProposal, got %T. Wrong subscription channel?",
-				msg.Data()))
+			t.Fatalf("expected a EventDataCompleteProposal, got %T. Wrong subscription channel?",
+				msg.Data())
 		}
 		if proposalEvent.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, proposalEvent.Height))
+			t.Fatalf("expected height %v, got %v", height, proposalEvent.Height)
 		}
 		if proposalEvent.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, proposalEvent.Round))
+			t.Fatalf("expected round %v, got %v", round, proposalEvent.Round)
 		}
 		if !proposalEvent.BlockID.Equals(propID) {
-			panic(fmt.Sprintf("Proposed block does not match expected block (%v != %v)", proposalEvent.BlockID, propID))
+			t.Fatalf("Proposed block does not match expected block (%v != %v)", proposalEvent.BlockID, propID)
 		}
 	}
 }
 
-func ensurePrecommit(voteCh <-chan tmpubsub.Message, height int64, round int32) {
-	ensureVote(voteCh, height, round, tmproto.PrecommitType)
+func ensurePrecommit(t *testing.T, voteCh <-chan tmpubsub.Message, height int64, round int32) {
+	t.Helper()
+	ensureVote(t, voteCh, height, round, tmproto.PrecommitType)
 }
 
-func ensurePrevote(voteCh <-chan tmpubsub.Message, height int64, round int32) {
-	ensureVote(voteCh, height, round, tmproto.PrevoteType)
+func ensurePrevote(t *testing.T, voteCh <-chan tmpubsub.Message, height int64, round int32) {
+	t.Helper()
+	ensureVote(t, voteCh, height, round, tmproto.PrevoteType)
 }
 
-func ensureVote(voteCh <-chan tmpubsub.Message, height int64, round int32,
+func ensureVote(t *testing.T, voteCh <-chan tmpubsub.Message, height int64, round int32,
 	voteType tmproto.SignedMsgType) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for NewVote event")
+		t.Fatalf("Timeout expired while waiting for NewVote event")
 	case msg := <-voteCh:
 		voteEvent, ok := msg.Data().(types.EventDataVote)
 		if !ok {
-			panic(fmt.Sprintf("expected a EventDataVote, got %T. Wrong subscription channel?",
-				msg.Data()))
+			t.Fatalf("expected a EventDataVote, got %T. Wrong subscription channel?",
+				msg.Data())
 		}
 		vote := voteEvent.Vote
 		if vote.Height != height {
-			panic(fmt.Sprintf("expected height %v, got %v", height, vote.Height))
+			t.Fatalf("expected height %v, got %v", height, vote.Height)
 		}
 		if vote.Round != round {
-			panic(fmt.Sprintf("expected round %v, got %v", round, vote.Round))
+			t.Fatalf("expected round %v, got %v", round, vote.Round)
 		}
 		if vote.Type != voteType {
-			panic(fmt.Sprintf("expected type %v, got %v", voteType, vote.Type))
+			t.Fatalf("expected type %v, got %v", voteType, vote.Type)
 		}
 	}
 }
 
-func ensurePrecommitTimeout(ch <-chan tmpubsub.Message) {
+func ensurePrecommitTimeout(t *testing.T, ch <-chan tmpubsub.Message) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for the Precommit to Timeout")
+		t.Fatalf("Timeout expired while waiting for the Precommit to Timeout")
 	case <-ch:
 	}
 }
 
-func ensureNewEventOnChannel(ch <-chan tmpubsub.Message) {
+func ensureNewEventOnChannel(t *testing.T, ch <-chan tmpubsub.Message) {
+	t.Helper()
 	select {
 	case <-time.After(ensureTimeout):
-		panic("Timeout expired while waiting for new activity on the channel")
+		t.Fatalf("Timeout expired while waiting for new activity on the channel")
 	case <-ch:
 	}
 }
@@ -711,6 +740,7 @@ func randConsensusState(
 	appFunc func() abci.Application,
 	configOpts ...func(*cfg.Config),
 ) ([]*State, cleanupFunc) {
+	t.Helper()
 
 	genDoc, privVals := factory.RandGenesisDoc(config, nValidators, false, 30)
 	css := make([]*State, nValidators)
@@ -731,7 +761,7 @@ func randConsensusState(
 			opt(thisConfig)
 		}
 
-		ensureDir(filepath.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
+		ensureDir(t, filepath.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
 
 		app := appFunc()
 
@@ -759,6 +789,7 @@ func randConsensusState(
 
 // nPeers = nValidators + nNotValidator
 func randConsensusNetWithPeers(
+	t *testing.T,
 	config *cfg.Config,
 	nValidators,
 	nPeers int,
@@ -768,6 +799,7 @@ func randConsensusNetWithPeers(
 ) ([]*State, *types.GenesisDoc, *cfg.Config, cleanupFunc) {
 	genDoc, privVals := factory.RandGenesisDoc(config, nValidators, false, testMinPower)
 	css := make([]*State, nPeers)
+	t.Helper()
 	logger := consensusLogger()
 
 	var peer0Config *cfg.Config
@@ -776,7 +808,7 @@ func randConsensusNetWithPeers(
 		state, _ := sm.MakeGenesisState(genDoc)
 		thisConfig := ResetConfig(fmt.Sprintf("%s_%d", testName, i))
 		configRootDirs = append(configRootDirs, thisConfig.RootDir)
-		ensureDir(filepath.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
+		ensureDir(t, filepath.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
 		if i == 0 {
 			peer0Config = thisConfig
 		}
@@ -786,16 +818,16 @@ func randConsensusNetWithPeers(
 		} else {
 			tempKeyFile, err := ioutil.TempFile("", "priv_validator_key_")
 			if err != nil {
-				panic(err)
+				t.Fatalf("error creating temp file for validator key: %s", err)
 			}
 			tempStateFile, err := ioutil.TempFile("", "priv_validator_state_")
 			if err != nil {
-				panic(err)
+				t.Fatalf("error loading validator state: %s", err)
 			}
 
 			privVal, err = privval.GenFilePV(tempKeyFile.Name(), tempStateFile.Name(), "")
 			if err != nil {
-				panic(err)
+				t.Fatalf("error generating validator key: %s", err)
 			}
 		}
 

internal/consensus/mempool_test.go

@@ -40,12 +40,12 @@ func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) {
 	newBlockCh := subscribe(cs.eventBus, types.EventQueryNewBlock)
 	startTestRound(cs, height, round)
 
-	ensureNewEventOnChannel(newBlockCh) // first block gets committed
-	ensureNoNewEventOnChannel(newBlockCh)
+	ensureNewEventOnChannel(t, newBlockCh) // first block gets committed
+	ensureNoNewEventOnChannel(t, newBlockCh)
 	deliverTxsRange(cs, 0, 1)
-	ensureNewEventOnChannel(newBlockCh) // commit txs
-	ensureNewEventOnChannel(newBlockCh) // commit updated app hash
-	ensureNoNewEventOnChannel(newBlockCh)
+	ensureNewEventOnChannel(t, newBlockCh) // commit txs
+	ensureNewEventOnChannel(t, newBlockCh) // commit updated app hash
+	ensureNoNewEventOnChannel(t, newBlockCh)
 }
 
 func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
@@ -63,9 +63,9 @@ func TestMempoolProgressAfterCreateEmptyBlocksInterval(t *testing.T) {
 	newBlockCh := subscribe(cs.eventBus, types.EventQueryNewBlock)
 	startTestRound(cs, cs.Height, cs.Round)
 
-	ensureNewEventOnChannel(newBlockCh)   // first block gets committed
-	ensureNoNewEventOnChannel(newBlockCh) // then we dont make a block ...
-	ensureNewEventOnChannel(newBlockCh)   // until the CreateEmptyBlocksInterval has passed
+	ensureNewEventOnChannel(t, newBlockCh)   // first block gets committed
+	ensureNoNewEventOnChannel(t, newBlockCh) // then we dont make a block ...
+	ensureNewEventOnChannel(t, newBlockCh)   // until the CreateEmptyBlocksInterval has passed
 }
 
 func TestMempoolProgressInHigherRound(t *testing.T) {
@@ -93,19 +93,19 @@ func TestMempoolProgressInHigherRound(t *testing.T) {
 	}
 	startTestRound(cs, height, round)
 
-	ensureNewRound(newRoundCh, height, round) // first round at first height
-	ensureNewEventOnChannel(newBlockCh)       // first block gets committed
+	ensureNewRound(t, newRoundCh, height, round) // first round at first height
+	ensureNewEventOnChannel(t, newBlockCh)       // first block gets committed
 
 	height++ // moving to the next height
 	round = 0
 
-	ensureNewRound(newRoundCh, height, round) // first round at next height
-	deliverTxsRange(cs, 0, 1)                 // we deliver txs, but dont set a proposal so we get the next round
-	ensureNewTimeout(timeoutCh, height, round, cs.config.TimeoutPropose.Nanoseconds())
+	ensureNewRound(t, newRoundCh, height, round) // first round at next height
+	deliverTxsRange(cs, 0, 1)                    // we deliver txs, but dont set a proposal so we get the next round
+	ensureNewTimeout(t, timeoutCh, height, round, cs.config.TimeoutPropose.Nanoseconds())
 
-	round++                                   // moving to the next round
-	ensureNewRound(newRoundCh, height, round) // wait for the next round
-	ensureNewEventOnChannel(newBlockCh)       // now we can commit the block
+	round++                                      // moving to the next round
+	ensureNewRound(t, newRoundCh, height, round) // wait for the next round
+	ensureNewEventOnChannel(t, newBlockCh)       // now we can commit the block
 }
 
 func deliverTxsRange(cs *State, start, end int) {

internal/consensus/reactor_test.go

@@ -13,7 +13,7 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
@@ -336,7 +336,7 @@ func TestReactorWithEvidence(t *testing.T) {
 
 		defer os.RemoveAll(thisConfig.RootDir)
 
-		ensureDir(path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
+		ensureDir(t, path.Dir(thisConfig.Consensus.WalFile()), 0700) // dir for wal
 		app := appFunc()
 		vals := types.TM2PB.ValidatorUpdates(state.Validators)
 		app.InitChain(abci.RequestInitChain{Validators: vals})
@@ -347,8 +347,8 @@ func TestReactorWithEvidence(t *testing.T) {
 
 		// one for mempool, one for consensus
 		mtx := new(tmsync.RWMutex)
-		proxyAppConnMem := abciclient.NewLocalClient(mtx, app)
-		proxyAppConnCon := abciclient.NewLocalClient(mtx, app)
+		proxyAppConnMem := abcicli.NewLocalClient(mtx, app)
+		proxyAppConnCon := abcicli.NewLocalClient(mtx, app)
 
 		mempool := mempoolv0.NewCListMempool(thisConfig.Mempool, proxyAppConnMem, 0)
 		mempool.SetLogger(log.TestingLogger().With("module", "mempool"))
@@ -627,6 +627,7 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 	nPeers := 7
 	nVals := 4
 	states, _, _, cleanup := randConsensusNetWithPeers(
+		t,
 		config,
 		nVals,
 		nPeers,

internal/consensus/replay.go

@@ -11,8 +11,8 @@ import (
 
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto/merkle"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 )

internal/consensus/replay_file.go

@@ -13,10 +13,10 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	tmos "github.com/tendermint/tendermint/libs/os"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"

internal/consensus/replay_stubs.go

@@ -3,12 +3,11 @@ package consensus
 import (
 	"context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/internal/libs/clist"
 	mempl "github.com/tendermint/tendermint/internal/mempool"
-	"github.com/tendermint/tendermint/internal/proxy"
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -54,11 +53,11 @@ func (emptyMempool) CloseWAL()      {}
 // the real app.
 
 func newMockProxyApp(appHash []byte, abciResponses *tmstate.ABCIResponses) proxy.AppConnConsensus {
-	clientCreator := abciclient.NewLocalCreator(&mockProxyApp{
+	clientCreator := proxy.NewLocalClientCreator(&mockProxyApp{
 		appHash:       appHash,
 		abciResponses: abciResponses,
 	})
-	cli, _ := clientCreator.NewClient()
+	cli, _ := clientCreator.NewABCIClient()
 	err := cli.Start()
 	if err != nil {
 		panic(err)

internal/consensus/replay_test.go

@@ -19,20 +19,19 @@ import (
 	"github.com/stretchr/testify/require"
 	dbm "github.com/tendermint/tm-db"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	mempl "github.com/tendermint/tendermint/internal/mempool"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	"github.com/tendermint/tendermint/privval"
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/store"
@@ -59,7 +58,7 @@ func startNewStateAndWaitForBlock(t *testing.T, consensusReplayConfig *cfg.Confi
 	logger := log.TestingLogger()
 	state, err := sm.MakeGenesisStateFromFile(consensusReplayConfig.GenesisFile())
 	require.NoError(t, err)
-	privValidator := loadPrivValidator(consensusReplayConfig)
+	privValidator := loadPrivValidator(t, consensusReplayConfig)
 	blockStore := store.NewBlockStore(dbm.NewMemDB())
 	cs := newStateWithConfigAndBlockStore(
 		consensusReplayConfig,
@@ -155,7 +154,7 @@ LOOP:
 		blockStore := store.NewBlockStore(blockDB)
 		state, err := sm.MakeGenesisStateFromFile(consensusReplayConfig.GenesisFile())
 		require.NoError(t, err)
-		privValidator := loadPrivValidator(consensusReplayConfig)
+		privValidator := loadPrivValidator(t, consensusReplayConfig)
 		cs := newStateWithConfigAndBlockStore(
 			consensusReplayConfig,
 			state,
@@ -322,6 +321,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 	nVals := 4
 
 	css, genDoc, config, cleanup := randConsensusNetWithPeers(
+		t,
 		config,
 		nVals,
 		nPeers,
@@ -346,15 +346,15 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 	// start the machine
 	startTestRound(css[0], height, round)
 	incrementHeight(vss...)
-	ensureNewRound(newRoundCh, height, 0)
-	ensureNewProposal(proposalCh, height, round)
+	ensureNewRound(t, newRoundCh, height, 0)
+	ensureNewProposal(t, proposalCh, height, round)
 	rs := css[0].GetRoundState()
 
 	signAddVotes(sim.Config, css[0], tmproto.PrecommitType,
 		rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(),
 		vss[1:nVals]...)
 
-	ensureNewRound(newRoundCh, height+1, 0)
+	ensureNewRound(t, newRoundCh, height+1, 0)
 
 	// HEIGHT 2
 	height++
@@ -381,12 +381,12 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 	if err := css[0].SetProposalAndBlock(proposal, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
 	}
-	ensureNewProposal(proposalCh, height, round)
+	ensureNewProposal(t, proposalCh, height, round)
 	rs = css[0].GetRoundState()
 	signAddVotes(sim.Config, css[0], tmproto.PrecommitType,
 		rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(),
 		vss[1:nVals]...)
-	ensureNewRound(newRoundCh, height+1, 0)
+	ensureNewRound(t, newRoundCh, height+1, 0)
 
 	// HEIGHT 3
 	height++
@@ -413,12 +413,12 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 	if err := css[0].SetProposalAndBlock(proposal, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
 	}
-	ensureNewProposal(proposalCh, height, round)
+	ensureNewProposal(t, proposalCh, height, round)
 	rs = css[0].GetRoundState()
 	signAddVotes(sim.Config, css[0], tmproto.PrecommitType,
 		rs.ProposalBlock.Hash(), rs.ProposalBlockParts.Header(),
 		vss[1:nVals]...)
-	ensureNewRound(newRoundCh, height+1, 0)
+	ensureNewRound(t, newRoundCh, height+1, 0)
 
 	// HEIGHT 4
 	height++
@@ -472,7 +472,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 	if err := css[0].SetProposalAndBlock(proposal, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
 	}
-	ensureNewProposal(proposalCh, height, round)
+	ensureNewProposal(t, proposalCh, height, round)
 
 	removeValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, 0)
 	err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), removeValidatorTx2, nil, mempl.TxInfo{})
@@ -488,7 +488,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 			rs.ProposalBlockParts.Header(), newVss[i])
 	}
 
-	ensureNewRound(newRoundCh, height+1, 0)
+	ensureNewRound(t, newRoundCh, height+1, 0)
 
 	// HEIGHT 5
 	height++
@@ -498,7 +498,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 	newVss[newVssIdx].VotingPower = 25
 	sort.Sort(ValidatorStubsByPower(newVss))
 	selfIndex = valIndexFn(0)
-	ensureNewProposal(proposalCh, height, round)
+	ensureNewProposal(t, proposalCh, height, round)
 	rs = css[0].GetRoundState()
 	for i := 0; i < nVals+1; i++ {
 		if i == selfIndex {
@@ -508,7 +508,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 			tmproto.PrecommitType, rs.ProposalBlock.Hash(),
 			rs.ProposalBlockParts.Header(), newVss[i])
 	}
-	ensureNewRound(newRoundCh, height+1, 0)
+	ensureNewRound(t, newRoundCh, height+1, 0)
 
 	// HEIGHT 6
 	height++
@@ -535,7 +535,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 	if err := css[0].SetProposalAndBlock(proposal, propBlock, propBlockParts, "some peer"); err != nil {
 		t.Fatal(err)
 	}
-	ensureNewProposal(proposalCh, height, round)
+	ensureNewProposal(t, proposalCh, height, round)
 	rs = css[0].GetRoundState()
 	for i := 0; i < nVals+3; i++ {
 		if i == selfIndex {
@@ -545,7 +545,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite {
 			tmproto.PrecommitType, rs.ProposalBlock.Hash(),
 			rs.ProposalBlockParts.Header(), newVss[i])
 	}
-	ensureNewRound(newRoundCh, height+1, 0)
+	ensureNewRound(t, newRoundCh, height+1, 0)
 
 	sim.Chain = make([]*types.Block, 0)
 	sim.Commits = make([]*types.Commit, 0)
@@ -741,7 +741,7 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod
 		filepath.Join(config.DBDir(), fmt.Sprintf("replay_test_%d_%d_a_r%d", nBlocks, mode, rand.Int())))
 	t.Cleanup(func() { require.NoError(t, kvstoreApp.Close()) })
 
-	clientCreator2 := abciclient.NewLocalCreator(kvstoreApp)
+	clientCreator2 := proxy.NewLocalClientCreator(kvstoreApp)
 	if nBlocks > 0 {
 		// run nBlocks against a new client to build up the app state.
 		// use a throwaway tendermint state
@@ -891,7 +891,7 @@ func buildTMStateFromChain(
 	kvstoreApp := kvstore.NewPersistentKVStoreApplication(
 		filepath.Join(config.DBDir(), fmt.Sprintf("replay_test_%d_%d_t", nBlocks, mode)))
 	defer kvstoreApp.Close()
-	clientCreator := abciclient.NewLocalCreator(kvstoreApp)
+	clientCreator := proxy.NewLocalClientCreator(kvstoreApp)
 
 	proxyApp := proxy.NewAppConns(clientCreator)
 	if err := proxyApp.Start(); err != nil {
@@ -959,7 +959,7 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	//		- 0x03
 	{
 		app := &badApp{numBlocks: 3, allHashesAreWrong: true}
-		clientCreator := abciclient.NewLocalCreator(app)
+		clientCreator := proxy.NewLocalClientCreator(app)
 		proxyApp := proxy.NewAppConns(clientCreator)
 		err := proxyApp.Start()
 		require.NoError(t, err)
@@ -983,7 +983,7 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) {
 	//		- RANDOM HASH
 	{
 		app := &badApp{numBlocks: 3, onlyLastHashIsWrong: true}
-		clientCreator := abciclient.NewLocalCreator(app)
+		clientCreator := proxy.NewLocalClientCreator(app)
 		proxyApp := proxy.NewAppConns(clientCreator)
 		err := proxyApp.Start()
 		require.NoError(t, err)
@@ -1226,7 +1226,7 @@ func TestHandshakeUpdatesValidators(t *testing.T) {
 	val, _ := factory.RandValidator(true, 10)
 	vals := types.NewValidatorSet([]*types.Validator{val})
 	app := &initChainApp{vals: types.TM2PB.ValidatorUpdates(vals)}
-	clientCreator := abciclient.NewLocalCreator(app)
+	clientCreator := proxy.NewLocalClientCreator(app)
 
 	config := ResetConfig("handshake_test_")
 	t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) })

internal/consensus/wal_generator.go

@@ -13,12 +13,11 @@ import (
 	"github.com/stretchr/testify/require"
 	db "github.com/tendermint/tm-db"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	cfg "github.com/tendermint/tendermint/config"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/privval"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"
@@ -65,7 +64,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(proxy.NewLocalClientCreator(app))
 	proxyApp.SetLogger(logger.With("module", "proxy"))
 	if err := proxyApp.Start(); err != nil {
 		return fmt.Errorf("failed to start proxy app connections: %w", err)

internal/mempool/v0/bench_test.go

@@ -6,14 +6,14 @@ import (
 	"sync/atomic"
 	"testing"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/internal/mempool"
+	"github.com/tendermint/tendermint/proxy"
 )
 
 func BenchmarkReap(b *testing.B) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 	mp.config.Size = 100000
@@ -34,7 +34,7 @@ func BenchmarkReap(b *testing.B) {
 
 func BenchmarkCheckTx(b *testing.B) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 
@@ -56,7 +56,7 @@ func BenchmarkCheckTx(b *testing.B) {
 
 func BenchmarkParallelCheckTx(b *testing.B) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 
@@ -81,7 +81,7 @@ func BenchmarkParallelCheckTx(b *testing.B) {
 
 func BenchmarkCheckDuplicateTx(b *testing.B) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 

internal/mempool/v0/cache_test.go

@@ -7,16 +7,16 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/internal/mempool"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 
 func TestCacheAfterUpdate(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 

internal/mempool/v0/clist_mempool.go

@@ -12,9 +12,9 @@ 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/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	tmmath "github.com/tendermint/tendermint/libs/math"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 

internal/mempool/v0/clist_mempool_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abciserver "github.com/tendermint/tendermint/abci/server"
 	abci "github.com/tendermint/tendermint/abci/types"
@@ -24,6 +23,7 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	"github.com/tendermint/tendermint/libs/service"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -31,12 +31,12 @@ import (
 // test.
 type cleanupFunc func()
 
-func newMempoolWithApp(cc abciclient.Creator) (*CListMempool, cleanupFunc) {
+func newMempoolWithApp(cc proxy.ClientCreator) (*CListMempool, cleanupFunc) {
 	return newMempoolWithAppAndConfig(cc, cfg.ResetTestRoot("mempool_test"))
 }
 
-func newMempoolWithAppAndConfig(cc abciclient.Creator, config *cfg.Config) (*CListMempool, cleanupFunc) {
-	appConnMem, _ := cc.NewClient()
+func newMempoolWithAppAndConfig(cc proxy.ClientCreator, config *cfg.Config) (*CListMempool, cleanupFunc) {
+	appConnMem, _ := cc.NewABCIClient()
 	appConnMem.SetLogger(log.TestingLogger().With("module", "abci-client", "connection", "mempool"))
 	err := appConnMem.Start()
 	if err != nil {
@@ -92,7 +92,7 @@ func checkTxs(t *testing.T, mp mempool.Mempool, count int, peerID uint16) types.
 
 func TestReapMaxBytesMaxGas(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 
@@ -141,7 +141,7 @@ func TestReapMaxBytesMaxGas(t *testing.T) {
 
 func TestMempoolFilters(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 	emptyTxArr := []types.Tx{[]byte{}}
@@ -180,7 +180,7 @@ func TestMempoolFilters(t *testing.T) {
 
 func TestMempoolUpdate(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 
@@ -216,7 +216,7 @@ func TestMempoolUpdate(t *testing.T) {
 
 func TestMempool_KeepInvalidTxsInCache(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	wcfg := cfg.DefaultConfig()
 	wcfg.Mempool.KeepInvalidTxsInCache = true
 	mp, cleanup := newMempoolWithAppAndConfig(cc, wcfg)
@@ -264,7 +264,7 @@ func TestMempool_KeepInvalidTxsInCache(t *testing.T) {
 
 func TestTxsAvailable(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 	mp.EnableTxsAvailable()
@@ -308,12 +308,12 @@ func TestTxsAvailable(t *testing.T) {
 
 func TestSerialReap(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 
 	mp, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 
-	appConnCon, _ := cc.NewClient()
+	appConnCon, _ := cc.NewABCIClient()
 	appConnCon.SetLogger(log.TestingLogger().With("module", "abci-client", "connection", "consensus"))
 	err := appConnCon.Start()
 	require.Nil(t, err)
@@ -419,7 +419,7 @@ func TestSerialReap(t *testing.T) {
 
 func TestMempool_CheckTxChecksTxSize(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	mempl, cleanup := newMempoolWithApp(cc)
 	defer cleanup()
 
@@ -464,7 +464,7 @@ func TestMempool_CheckTxChecksTxSize(t *testing.T) {
 
 func TestMempoolTxsBytes(t *testing.T) {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	config := cfg.ResetTestRoot("mempool_test")
 	config.Mempool.MaxTxsBytes = 10
 	mp, cleanup := newMempoolWithAppAndConfig(cc, config)
@@ -507,7 +507,7 @@ func TestMempoolTxsBytes(t *testing.T) {
 
 	// 6. zero after tx is rechecked and removed due to not being valid anymore
 	app2 := kvstore.NewApplication()
-	cc = abciclient.NewLocalCreator(app2)
+	cc = proxy.NewLocalClientCreator(app2)
 	mp, cleanup = newMempoolWithApp(cc)
 	defer cleanup()
 
@@ -518,7 +518,7 @@ func TestMempoolTxsBytes(t *testing.T) {
 	require.NoError(t, err)
 	assert.EqualValues(t, 8, mp.SizeBytes())
 
-	appConnCon, _ := cc.NewClient()
+	appConnCon, _ := cc.NewABCIClient()
 	appConnCon.SetLogger(log.TestingLogger().With("module", "abci-client", "connection", "consensus"))
 	err = appConnCon.Start()
 	require.Nil(t, err)
@@ -597,10 +597,10 @@ func newRemoteApp(
 	addr string,
 	app abci.Application,
 ) (
-	clientCreator abciclient.Creator,
+	clientCreator proxy.ClientCreator,
 	server service.Service,
 ) {
-	clientCreator = abciclient.NewRemoteCreator(addr, "socket", true)
+	clientCreator = proxy.NewRemoteClientCreator(addr, "socket", true)
 
 	// Start server
 	server = abciserver.NewSocketServer(addr, app)

internal/mempool/v0/reactor_test.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
@@ -18,6 +17,7 @@ import (
 	"github.com/tendermint/tendermint/libs/log"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	protomem "github.com/tendermint/tendermint/proto/tendermint/mempool"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -55,7 +55,7 @@ func setup(t *testing.T, cfg *cfg.MempoolConfig, numNodes int, chBuf uint) *reac
 
 	for nodeID := range rts.network.Nodes {
 		rts.kvstores[nodeID] = kvstore.NewApplication()
-		cc := abciclient.NewLocalCreator(rts.kvstores[nodeID])
+		cc := proxy.NewLocalClientCreator(rts.kvstores[nodeID])
 
 		mempool, memCleanup := newMempoolWithApp(cc)
 		t.Cleanup(memCleanup)

internal/mempool/v1/mempool.go

@@ -12,9 +12,9 @@ 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/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	tmmath "github.com/tendermint/tendermint/libs/math"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 

internal/mempool/v1/mempool_test.go

@@ -15,14 +15,13 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/require"
-
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/code"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/mempool"
 	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -77,12 +76,12 @@ func setup(t testing.TB, cacheSize int, options ...TxMempoolOption) *TxMempool {
 	t.Helper()
 
 	app := &application{kvstore.NewApplication()}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 
 	cfg := config.ResetTestRoot(strings.ReplaceAll(t.Name(), "/", "|"))
 	cfg.Mempool.CacheSize = cacheSize
 
-	appConnMem, err := cc.NewClient()
+	appConnMem, err := cc.NewABCIClient()
 	require.NoError(t, err)
 	require.NoError(t, appConnMem.Start())
 

internal/proxy/client.go

@@ -1,34 +0,0 @@
-package proxy
-
-import (
-	"io"
-
-	abciclient "github.com/tendermint/tendermint/abci/client"
-	"github.com/tendermint/tendermint/abci/example/kvstore"
-	"github.com/tendermint/tendermint/abci/types"
-)
-
-// DefaultClientCreator returns a default ClientCreator, which will create a
-// local client if addr is one of: 'kvstore',
-// 'persistent_kvstore' or 'noop', otherwise - a remote client.
-//
-// The Closer is a noop except for persistent_kvstore applications,
-// which will clean up the store.
-func DefaultClientCreator(addr, transport, dbDir string) (abciclient.Creator, io.Closer) {
-	switch addr {
-	case "kvstore":
-		return abciclient.NewLocalCreator(kvstore.NewApplication()), noopCloser{}
-	case "persistent_kvstore":
-		app := kvstore.NewPersistentKVStoreApplication(dbDir)
-		return abciclient.NewLocalCreator(app), app
-	case "noop":
-		return abciclient.NewLocalCreator(types.NewBaseApplication()), noopCloser{}
-	default:
-		mustConnect := false // loop retrying
-		return abciclient.NewRemoteCreator(addr, transport, mustConnect), noopCloser{}
-	}
-}
-
-type noopCloser struct{}
-
-func (noopCloser) Close() error { return nil }

internal/statesync/reactor.go

@@ -14,12 +14,12 @@ import (
 	"github.com/tendermint/tendermint/config"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
 	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 	"github.com/tendermint/tendermint/light"
 	"github.com/tendermint/tendermint/light/provider"
 	ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"

internal/statesync/reactor_test.go

@@ -16,14 +16,14 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/proxy"
-	proxymocks "github.com/tendermint/tendermint/internal/proxy/mocks"
 	"github.com/tendermint/tendermint/internal/statesync/mocks"
 	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/light/provider"
 	ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/proxy"
+	proxymocks "github.com/tendermint/tendermint/proxy/mocks"
 	smmocks "github.com/tendermint/tendermint/state/mocks"
 	"github.com/tendermint/tendermint/store"
 	"github.com/tendermint/tendermint/types"

internal/statesync/syncer.go

@@ -11,10 +11,10 @@ import (
 	"github.com/tendermint/tendermint/config"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
 	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/light"
 	ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 )

internal/statesync/syncer_test.go

@@ -13,10 +13,10 @@ import (
 
 	abci "github.com/tendermint/tendermint/abci/types"
 	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
-	"github.com/tendermint/tendermint/internal/proxy"
-	proxymocks "github.com/tendermint/tendermint/internal/proxy/mocks"
 	"github.com/tendermint/tendermint/internal/statesync/mocks"
 	ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync"
+	"github.com/tendermint/tendermint/proxy"
+	proxymocks "github.com/tendermint/tendermint/proxy/mocks"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/types"
 	"github.com/tendermint/tendermint/version"

node/node.go

@@ -14,7 +14,6 @@ import (
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/rs/cors"
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
@@ -22,7 +21,6 @@ import (
 	"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"
 	"github.com/tendermint/tendermint/internal/statesync"
 	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
@@ -32,6 +30,7 @@ import (
 	tmtime "github.com/tendermint/tendermint/libs/time"
 	"github.com/tendermint/tendermint/privval"
 	tmgrpc "github.com/tendermint/tendermint/privval/grpc"
+	"github.com/tendermint/tendermint/proxy"
 	rpccore "github.com/tendermint/tendermint/rpc/core"
 	grpccore "github.com/tendermint/tendermint/rpc/grpc"
 	rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server"
@@ -120,7 +119,7 @@ func newDefaultNode(config *cfg.Config, logger log.Logger) (service.Service, err
 func makeNode(config *cfg.Config,
 	privValidator types.PrivValidator,
 	nodeKey types.NodeKey,
-	clientCreator abciclient.Creator,
+	clientCreator proxy.ClientCreator,
 	genesisDocProvider genesisDocProvider,
 	dbProvider cfg.DBProvider,
 	logger log.Logger) (service.Service, error) {

node/node_test.go

@@ -16,21 +16,21 @@ import (
 
 	dbm "github.com/tendermint/tm-db"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	"github.com/tendermint/tendermint/crypto/tmhash"
+
 	"github.com/tendermint/tendermint/internal/evidence"
 	"github.com/tendermint/tendermint/internal/mempool"
 	mempoolv0 "github.com/tendermint/tendermint/internal/mempool/v0"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/internal/test/factory"
 	"github.com/tendermint/tendermint/libs/log"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmtime "github.com/tendermint/tendermint/libs/time"
 	"github.com/tendermint/tendermint/privval"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/state/indexer"
 	"github.com/tendermint/tendermint/store"
@@ -214,7 +214,7 @@ func testFreeAddr(t *testing.T) string {
 func TestCreateProposalBlock(t *testing.T) {
 	config := cfg.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(config.RootDir)
-	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
+	cc := proxy.NewLocalClientCreator(kvstore.NewApplication())
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)
@@ -306,7 +306,7 @@ func TestCreateProposalBlock(t *testing.T) {
 func TestMaxTxsProposalBlockSize(t *testing.T) {
 	config := cfg.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(config.RootDir)
-	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
+	cc := proxy.NewLocalClientCreator(kvstore.NewApplication())
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)
@@ -368,7 +368,7 @@ func TestMaxTxsProposalBlockSize(t *testing.T) {
 func TestMaxProposalBlockSize(t *testing.T) {
 	config := cfg.ResetTestRoot("node_create_proposal")
 	defer os.RemoveAll(config.RootDir)
-	cc := abciclient.NewLocalCreator(kvstore.NewApplication())
+	cc := proxy.NewLocalClientCreator(kvstore.NewApplication())
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)

node/public.go

@@ -4,11 +4,11 @@ package node
 import (
 	"fmt"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 	"github.com/tendermint/tendermint/privval"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -28,7 +28,7 @@ func NewDefault(conf *config.Config, logger log.Logger) (service.Service, error)
 // value of the final argument.
 func New(conf *config.Config,
 	logger log.Logger,
-	cf abciclient.Creator,
+	cf proxy.ClientCreator,
 	gen *types.GenesisDoc,
 ) (service.Service, error) {
 	nodeKey, err := types.LoadOrGenNodeKey(conf.NodeKeyFile())

node/setup.go

@@ -12,7 +12,6 @@ import (
 
 	dbm "github.com/tendermint/tm-db"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
@@ -25,12 +24,12 @@ import (
 	mempoolv1 "github.com/tendermint/tendermint/internal/mempool/v1"
 	"github.com/tendermint/tendermint/internal/p2p"
 	"github.com/tendermint/tendermint/internal/p2p/pex"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/internal/statesync"
 	"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/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/state/indexer"
 	"github.com/tendermint/tendermint/state/indexer/sink"
@@ -51,7 +50,7 @@ func initDBs(config *cfg.Config, dbProvider cfg.DBProvider) (blockStore *store.B
 	return
 }
 
-func createAndStartProxyAppConns(clientCreator abciclient.Creator, logger log.Logger) (proxy.AppConns, error) {
+func createAndStartProxyAppConns(clientCreator proxy.ClientCreator, logger log.Logger) (proxy.AppConns, error) {
 	proxyApp := proxy.NewAppConns(clientCreator)
 	proxyApp.SetLogger(logger.With("module", "proxy"))
 	if err := proxyApp.Start(); err != nil {

proxy/app_conn.go

@@ -3,7 +3,7 @@ package proxy
 import (
 	"context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/types"
 )
 
@@ -13,25 +13,25 @@ import (
 // Enforce which abci msgs can be sent on a connection at the type level
 
 type AppConnConsensus interface {
-	SetResponseCallback(abciclient.Callback)
+	SetResponseCallback(abcicli.Callback)
 	Error() error
 
 	InitChainSync(context.Context, types.RequestInitChain) (*types.ResponseInitChain, error)
 
 	BeginBlockSync(context.Context, types.RequestBeginBlock) (*types.ResponseBeginBlock, error)
-	DeliverTxAsync(context.Context, types.RequestDeliverTx) (*abciclient.ReqRes, error)
+	DeliverTxAsync(context.Context, types.RequestDeliverTx) (*abcicli.ReqRes, error)
 	EndBlockSync(context.Context, types.RequestEndBlock) (*types.ResponseEndBlock, error)
 	CommitSync(context.Context) (*types.ResponseCommit, error)
 }
 
 type AppConnMempool interface {
-	SetResponseCallback(abciclient.Callback)
+	SetResponseCallback(abcicli.Callback)
 	Error() error
 
-	CheckTxAsync(context.Context, types.RequestCheckTx) (*abciclient.ReqRes, error)
+	CheckTxAsync(context.Context, types.RequestCheckTx) (*abcicli.ReqRes, error)
 	CheckTxSync(context.Context, types.RequestCheckTx) (*types.ResponseCheckTx, error)
 
-	FlushAsync(context.Context) (*abciclient.ReqRes, error)
+	FlushAsync(context.Context) (*abcicli.ReqRes, error)
 	FlushSync(context.Context) error
 }
 
@@ -53,19 +53,19 @@ type AppConnSnapshot interface {
 }
 
 //-----------------------------------------------------------------------------------------
-// Implements AppConnConsensus (subset of abciclient.Client)
+// Implements AppConnConsensus (subset of abcicli.Client)
 
 type appConnConsensus struct {
-	appConn abciclient.Client
+	appConn abcicli.Client
 }
 
-func NewAppConnConsensus(appConn abciclient.Client) AppConnConsensus {
+func NewAppConnConsensus(appConn abcicli.Client) AppConnConsensus {
 	return &appConnConsensus{
 		appConn: appConn,
 	}
 }
 
-func (app *appConnConsensus) SetResponseCallback(cb abciclient.Callback) {
+func (app *appConnConsensus) SetResponseCallback(cb abcicli.Callback) {
 	app.appConn.SetResponseCallback(cb)
 }
 
@@ -87,10 +87,7 @@ func (app *appConnConsensus) BeginBlockSync(
 	return app.appConn.BeginBlockSync(ctx, req)
 }
 
-func (app *appConnConsensus) DeliverTxAsync(
-	ctx context.Context,
-	req types.RequestDeliverTx,
-) (*abciclient.ReqRes, error) {
+func (app *appConnConsensus) DeliverTxAsync(ctx context.Context, req types.RequestDeliverTx) (*abcicli.ReqRes, error) {
 	return app.appConn.DeliverTxAsync(ctx, req)
 }
 
@@ -106,19 +103,19 @@ func (app *appConnConsensus) CommitSync(ctx context.Context) (*types.ResponseCom
 }
 
 //------------------------------------------------
-// Implements AppConnMempool (subset of abciclient.Client)
+// Implements AppConnMempool (subset of abcicli.Client)
 
 type appConnMempool struct {
-	appConn abciclient.Client
+	appConn abcicli.Client
 }
 
-func NewAppConnMempool(appConn abciclient.Client) AppConnMempool {
+func NewAppConnMempool(appConn abcicli.Client) AppConnMempool {
 	return &appConnMempool{
 		appConn: appConn,
 	}
 }
 
-func (app *appConnMempool) SetResponseCallback(cb abciclient.Callback) {
+func (app *appConnMempool) SetResponseCallback(cb abcicli.Callback) {
 	app.appConn.SetResponseCallback(cb)
 }
 
@@ -126,7 +123,7 @@ func (app *appConnMempool) Error() error {
 	return app.appConn.Error()
 }
 
-func (app *appConnMempool) FlushAsync(ctx context.Context) (*abciclient.ReqRes, error) {
+func (app *appConnMempool) FlushAsync(ctx context.Context) (*abcicli.ReqRes, error) {
 	return app.appConn.FlushAsync(ctx)
 }
 
@@ -134,7 +131,7 @@ func (app *appConnMempool) FlushSync(ctx context.Context) error {
 	return app.appConn.FlushSync(ctx)
 }
 
-func (app *appConnMempool) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*abciclient.ReqRes, error) {
+func (app *appConnMempool) CheckTxAsync(ctx context.Context, req types.RequestCheckTx) (*abcicli.ReqRes, error) {
 	return app.appConn.CheckTxAsync(ctx, req)
 }
 
@@ -143,13 +140,13 @@ func (app *appConnMempool) CheckTxSync(ctx context.Context, req types.RequestChe
 }
 
 //------------------------------------------------
-// Implements AppConnQuery (subset of abciclient.Client)
+// Implements AppConnQuery (subset of abcicli.Client)
 
 type appConnQuery struct {
-	appConn abciclient.Client
+	appConn abcicli.Client
 }
 
-func NewAppConnQuery(appConn abciclient.Client) AppConnQuery {
+func NewAppConnQuery(appConn abcicli.Client) AppConnQuery {
 	return &appConnQuery{
 		appConn: appConn,
 	}
@@ -172,13 +169,13 @@ func (app *appConnQuery) QuerySync(ctx context.Context, reqQuery types.RequestQu
 }
 
 //------------------------------------------------
-// Implements AppConnSnapshot (subset of abciclient.Client)
+// Implements AppConnSnapshot (subset of abcicli.Client)
 
 type appConnSnapshot struct {
-	appConn abciclient.Client
+	appConn abcicli.Client
 }
 
-func NewAppConnSnapshot(appConn abciclient.Client) AppConnSnapshot {
+func NewAppConnSnapshot(appConn abcicli.Client) AppConnSnapshot {
 	return &appConnSnapshot{
 		appConn: appConn,
 	}

proxy/app_conn_test.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/abci/server"
 	"github.com/tendermint/tendermint/abci/types"
@@ -17,20 +17,20 @@ import (
 //----------------------------------------
 
 type appConnTestI interface {
-	EchoAsync(ctx context.Context, msg string) (*abciclient.ReqRes, error)
+	EchoAsync(ctx context.Context, msg string) (*abcicli.ReqRes, error)
 	FlushSync(context.Context) error
 	InfoSync(context.Context, types.RequestInfo) (*types.ResponseInfo, error)
 }
 
 type appConnTest struct {
-	appConn abciclient.Client
+	appConn abcicli.Client
 }
 
-func newAppConnTest(appConn abciclient.Client) appConnTestI {
+func newAppConnTest(appConn abcicli.Client) appConnTestI {
 	return &appConnTest{appConn}
 }
 
-func (app *appConnTest) EchoAsync(ctx context.Context, msg string) (*abciclient.ReqRes, error) {
+func (app *appConnTest) EchoAsync(ctx context.Context, msg string) (*abcicli.ReqRes, error) {
 	return app.appConn.EchoAsync(ctx, msg)
 }
 
@@ -48,7 +48,7 @@ var SOCKET = "socket"
 
 func TestEcho(t *testing.T) {
 	sockPath := fmt.Sprintf("unix:///tmp/echo_%v.sock", tmrand.Str(6))
-	clientCreator := abciclient.NewRemoteCreator(sockPath, SOCKET, true)
+	clientCreator := NewRemoteClientCreator(sockPath, SOCKET, true)
 
 	// Start server
 	s := server.NewSocketServer(sockPath, kvstore.NewApplication())
@@ -63,7 +63,7 @@ func TestEcho(t *testing.T) {
 	})
 
 	// Start client
-	cli, err := clientCreator.NewClient()
+	cli, err := clientCreator.NewABCIClient()
 	if err != nil {
 		t.Fatalf("Error creating ABCI client: %v", err.Error())
 	}
@@ -96,7 +96,7 @@ func TestEcho(t *testing.T) {
 func BenchmarkEcho(b *testing.B) {
 	b.StopTimer() // Initialize
 	sockPath := fmt.Sprintf("unix:///tmp/echo_%v.sock", tmrand.Str(6))
-	clientCreator := abciclient.NewRemoteCreator(sockPath, SOCKET, true)
+	clientCreator := NewRemoteClientCreator(sockPath, SOCKET, true)
 
 	// Start server
 	s := server.NewSocketServer(sockPath, kvstore.NewApplication())
@@ -111,7 +111,7 @@ func BenchmarkEcho(b *testing.B) {
 	})
 
 	// Start client
-	cli, err := clientCreator.NewClient()
+	cli, err := clientCreator.NewABCIClient()
 	if err != nil {
 		b.Fatalf("Error creating ABCI client: %v", err.Error())
 	}
@@ -149,7 +149,7 @@ func BenchmarkEcho(b *testing.B) {
 
 func TestInfo(t *testing.T) {
 	sockPath := fmt.Sprintf("unix:///tmp/echo_%v.sock", tmrand.Str(6))
-	clientCreator := abciclient.NewRemoteCreator(sockPath, SOCKET, true)
+	clientCreator := NewRemoteClientCreator(sockPath, SOCKET, true)
 
 	// Start server
 	s := server.NewSocketServer(sockPath, kvstore.NewApplication())
@@ -164,7 +164,7 @@ func TestInfo(t *testing.T) {
 	})
 
 	// Start client
-	cli, err := clientCreator.NewClient()
+	cli, err := clientCreator.NewABCIClient()
 	if err != nil {
 		t.Fatalf("Error creating ABCI client: %v", err.Error())
 	}

proxy/client.go

@@ -0,0 +1,94 @@
+package proxy
+
+import (
+	"fmt"
+	"io"
+
+	abcicli "github.com/tendermint/tendermint/abci/client"
+	"github.com/tendermint/tendermint/abci/example/kvstore"
+	"github.com/tendermint/tendermint/abci/types"
+	tmsync "github.com/tendermint/tendermint/internal/libs/sync"
+)
+
+//go:generate ../scripts/mockery_generate.sh ClientCreator
+
+// ClientCreator creates new ABCI clients.
+type ClientCreator interface {
+	// NewABCIClient returns a new ABCI client.
+	NewABCIClient() (abcicli.Client, error)
+}
+
+//----------------------------------------------------
+// local proxy uses a mutex on an in-proc app
+
+type localClientCreator struct {
+	mtx *tmsync.RWMutex
+	app types.Application
+}
+
+// NewLocalClientCreator returns a ClientCreator for the given app,
+// which will be running locally.
+func NewLocalClientCreator(app types.Application) ClientCreator {
+	return &localClientCreator{
+		mtx: new(tmsync.RWMutex),
+		app: app,
+	}
+}
+
+func (l *localClientCreator) NewABCIClient() (abcicli.Client, error) {
+	return abcicli.NewLocalClient(l.mtx, l.app), nil
+}
+
+//---------------------------------------------------------------
+// remote proxy opens new connections to an external app process
+
+type remoteClientCreator struct {
+	addr        string
+	transport   string
+	mustConnect bool
+}
+
+// NewRemoteClientCreator returns a ClientCreator for the given address (e.g.
+// "192.168.0.1") and transport (e.g. "tcp"). Set mustConnect to true if you
+// want the client to connect before reporting success.
+func NewRemoteClientCreator(addr, transport string, mustConnect bool) ClientCreator {
+	return &remoteClientCreator{
+		addr:        addr,
+		transport:   transport,
+		mustConnect: mustConnect,
+	}
+}
+
+func (r *remoteClientCreator) NewABCIClient() (abcicli.Client, error) {
+	remoteApp, err := abcicli.NewClient(r.addr, r.transport, r.mustConnect)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to proxy: %w", err)
+	}
+
+	return remoteApp, nil
+}
+
+// DefaultClientCreator returns a default ClientCreator, which will create a
+// local client if addr is one of: 'kvstore',
+// 'persistent_kvstore' or 'noop', otherwise - a remote client.
+//
+// The Closer is a noop except for persistent_kvstore applications,
+// which will clean up the store.
+func DefaultClientCreator(addr, transport, dbDir string) (ClientCreator, io.Closer) {
+	switch addr {
+	case "kvstore":
+		return NewLocalClientCreator(kvstore.NewApplication()), noopCloser{}
+	case "persistent_kvstore":
+		app := kvstore.NewPersistentKVStoreApplication(dbDir)
+		return NewLocalClientCreator(app), app
+	case "noop":
+		return NewLocalClientCreator(types.NewBaseApplication()), noopCloser{}
+	default:
+		mustConnect := false // loop retrying
+		return NewRemoteClientCreator(addr, transport, mustConnect), noopCloser{}
+	}
+}
+
+type noopCloser struct{}
+
+func (noopCloser) Close() error { return nil }

proxy/mocks/app_conn_consensus.go

@@ -5,7 +5,7 @@ package mocks
 import (
 	context "context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 
 	mock "github.com/stretchr/testify/mock"
 
@@ -64,15 +64,15 @@ func (_m *AppConnConsensus) CommitSync(_a0 context.Context) (*types.ResponseComm
 }
 
 // DeliverTxAsync provides a mock function with given fields: _a0, _a1
-func (_m *AppConnConsensus) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abciclient.ReqRes, error) {
+func (_m *AppConnConsensus) DeliverTxAsync(_a0 context.Context, _a1 types.RequestDeliverTx) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestDeliverTx) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -147,6 +147,6 @@ func (_m *AppConnConsensus) InitChainSync(_a0 context.Context, _a1 types.Request
 }
 
 // SetResponseCallback provides a mock function with given fields: _a0
-func (_m *AppConnConsensus) SetResponseCallback(_a0 abciclient.Callback) {
+func (_m *AppConnConsensus) SetResponseCallback(_a0 abcicli.Callback) {
 	_m.Called(_a0)
 }

proxy/mocks/app_conn_mempool.go

@@ -5,7 +5,7 @@ package mocks
 import (
 	context "context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 
 	mock "github.com/stretchr/testify/mock"
 
@@ -18,15 +18,15 @@ type AppConnMempool struct {
 }
 
 // CheckTxAsync provides a mock function with given fields: _a0, _a1
-func (_m *AppConnMempool) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abciclient.ReqRes, error) {
+func (_m *AppConnMempool) CheckTxAsync(_a0 context.Context, _a1 types.RequestCheckTx) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0, _a1)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context, types.RequestCheckTx) *abcicli.ReqRes); ok {
 		r0 = rf(_a0, _a1)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -78,15 +78,15 @@ func (_m *AppConnMempool) Error() error {
 }
 
 // FlushAsync provides a mock function with given fields: _a0
-func (_m *AppConnMempool) FlushAsync(_a0 context.Context) (*abciclient.ReqRes, error) {
+func (_m *AppConnMempool) FlushAsync(_a0 context.Context) (*abcicli.ReqRes, error) {
 	ret := _m.Called(_a0)
 
-	var r0 *abciclient.ReqRes
-	if rf, ok := ret.Get(0).(func(context.Context) *abciclient.ReqRes); ok {
+	var r0 *abcicli.ReqRes
+	if rf, ok := ret.Get(0).(func(context.Context) *abcicli.ReqRes); ok {
 		r0 = rf(_a0)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*abciclient.ReqRes)
+			r0 = ret.Get(0).(*abcicli.ReqRes)
 		}
 	}
 
@@ -115,6 +115,6 @@ func (_m *AppConnMempool) FlushSync(_a0 context.Context) error {
 }
 
 // SetResponseCallback provides a mock function with given fields: _a0
-func (_m *AppConnMempool) SetResponseCallback(_a0 abciclient.Callback) {
+func (_m *AppConnMempool) SetResponseCallback(_a0 abcicli.Callback) {
 	_m.Called(_a0)
 }

proxy/mocks/client_creator.go

@@ -4,7 +4,7 @@ package mocks
 
 import (
 	mock "github.com/stretchr/testify/mock"
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 )
 
 // ClientCreator is an autogenerated mock type for the ClientCreator type
@@ -12,16 +12,16 @@ type ClientCreator struct {
 	mock.Mock
 }
 
-// NewClient provides a mock function with given fields:
-func (_m *ClientCreator) NewClient() (abciclient.Client, error) {
+// NewABCIClient provides a mock function with given fields:
+func (_m *ClientCreator) NewABCIClient() (abcicli.Client, error) {
 	ret := _m.Called()
 
-	var r0 abciclient.Client
-	if rf, ok := ret.Get(0).(func() abciclient.Client); ok {
+	var r0 abcicli.Client
+	if rf, ok := ret.Get(0).(func() abcicli.Client); ok {
 		r0 = rf()
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(abciclient.Client)
+			r0 = ret.Get(0).(abcicli.Client)
 		}
 	}
 

proxy/multi_app_conn.go

@@ -5,7 +5,7 @@ import (
 	"os"
 	"syscall"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
+	abcicli "github.com/tendermint/tendermint/abci/client"
 	tmlog "github.com/tendermint/tendermint/libs/log"
 	"github.com/tendermint/tendermint/libs/service"
 )
@@ -33,7 +33,7 @@ type AppConns interface {
 }
 
 // NewAppConns calls NewMultiAppConn.
-func NewAppConns(clientCreator abciclient.Creator) AppConns {
+func NewAppConns(clientCreator ClientCreator) AppConns {
 	return NewMultiAppConn(clientCreator)
 }
 
@@ -50,16 +50,16 @@ type multiAppConn struct {
 	queryConn     AppConnQuery
 	snapshotConn  AppConnSnapshot
 
-	consensusConnClient abciclient.Client
-	mempoolConnClient   abciclient.Client
-	queryConnClient     abciclient.Client
-	snapshotConnClient  abciclient.Client
+	consensusConnClient abcicli.Client
+	mempoolConnClient   abcicli.Client
+	queryConnClient     abcicli.Client
+	snapshotConnClient  abcicli.Client
 
-	clientCreator abciclient.Creator
+	clientCreator ClientCreator
 }
 
 // NewMultiAppConn makes all necessary abci connections to the application.
-func NewMultiAppConn(clientCreator abciclient.Creator) AppConns {
+func NewMultiAppConn(clientCreator ClientCreator) AppConns {
 	multiAppConn := &multiAppConn{
 		clientCreator: clientCreator,
 	}
@@ -178,8 +178,8 @@ func (app *multiAppConn) stopAllClients() {
 	}
 }
 
-func (app *multiAppConn) abciClientFor(conn string) (abciclient.Client, error) {
-	c, err := app.clientCreator.NewClient()
+func (app *multiAppConn) abciClientFor(conn string) (abcicli.Client, error) {
+	c, err := app.clientCreator.NewABCIClient()
 	if err != nil {
 		return nil, fmt.Errorf("error creating ABCI client (%s connection): %w", conn, err)
 	}

proxy/multi_app_conn_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	abcimocks "github.com/tendermint/tendermint/abci/client/mocks"
-	"github.com/tendermint/tendermint/internal/proxy/mocks"
+	"github.com/tendermint/tendermint/proxy/mocks"
 )
 
 func TestAppConns_Start_Stop(t *testing.T) {
@@ -26,7 +26,7 @@ func TestAppConns_Start_Stop(t *testing.T) {
 	clientMock.On("Stop").Return(nil).Times(4)
 	clientMock.On("Quit").Return(quitCh).Times(4)
 
-	clientCreatorMock.On("NewClient").Return(clientMock, nil).Times(4)
+	clientCreatorMock.On("NewABCIClient").Return(clientMock, nil).Times(4)
 
 	appConns := NewAppConns(clientCreatorMock)
 
@@ -66,7 +66,7 @@ func TestAppConns_Failure(t *testing.T) {
 	clientMock.On("Quit").Return(recvQuitCh)
 	clientMock.On("Error").Return(errors.New("EOF")).Once()
 
-	clientCreatorMock.On("NewClient").Return(clientMock, nil)
+	clientCreatorMock.On("NewABCIClient").Return(clientMock, nil)
 
 	appConns := NewAppConns(clientCreatorMock)
 

rpc/client/mock/abci.go

@@ -4,8 +4,8 @@ import (
 	"context"
 
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/bytes"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/rpc/client"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	"github.com/tendermint/tendermint/types"

rpc/core/abci.go

@@ -2,8 +2,8 @@ package core
 
 import (
 	abci "github.com/tendermint/tendermint/abci/types"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/bytes"
+	"github.com/tendermint/tendermint/proxy"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )

rpc/core/env.go

@@ -10,9 +10,9 @@ import (
 	"github.com/tendermint/tendermint/internal/consensus"
 	mempl "github.com/tendermint/tendermint/internal/mempool"
 	"github.com/tendermint/tendermint/internal/p2p"
-	"github.com/tendermint/tendermint/internal/proxy"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 	"github.com/tendermint/tendermint/libs/log"
+	"github.com/tendermint/tendermint/proxy"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/state/indexer"

rpc/grpc/types.pb.go

@@ -6,15 +6,14 @@ package coregrpc
 import (
 	context "context"
 	fmt "fmt"
-	io "io"
-	math "math"
-	math_bits "math/bits"
-
 	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.

rpc/test/helpers.go

@@ -6,13 +6,13 @@ import (
 	"os"
 	"time"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/libs/log"
 	tmnet "github.com/tendermint/tendermint/libs/net"
 	"github.com/tendermint/tendermint/libs/service"
 	nm "github.com/tendermint/tendermint/node"
+	"github.com/tendermint/tendermint/proxy"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	core_grpc "github.com/tendermint/tendermint/rpc/grpc"
 	rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client"
@@ -100,7 +100,7 @@ func StartTendermint(ctx context.Context,
 	} else {
 		logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false)
 	}
-	papp := abciclient.NewLocalCreator(app)
+	papp := proxy.NewLocalClientCreator(app)
 	node, err := nm.New(conf, logger, papp, nil)
 	if err != nil {
 		return nil, func(_ context.Context) error { return nil }, err

state/execution.go

@@ -10,9 +10,9 @@ import (
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/internal/libs/fail"
 	mempl "github.com/tendermint/tendermint/internal/mempool"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
+	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 )
 

state/execution_test.go

@@ -9,16 +9,15 @@ import (
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	mmock "github.com/tendermint/tendermint/internal/mempool/mock"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/log"
 	tmtime "github.com/tendermint/tendermint/libs/time"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	"github.com/tendermint/tendermint/state/mocks"
 	sf "github.com/tendermint/tendermint/state/test/factory"
@@ -35,7 +34,7 @@ var (
 
 func TestApplyBlock(t *testing.T) {
 	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)
@@ -60,7 +59,7 @@ func TestApplyBlock(t *testing.T) {
 // TestBeginBlockValidators ensures we send absent validators list.
 func TestBeginBlockValidators(t *testing.T) {
 	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)
@@ -123,7 +122,7 @@ func TestBeginBlockValidators(t *testing.T) {
 // TestBeginBlockByzantineValidators ensures we send byzantine validators list.
 func TestBeginBlockByzantineValidators(t *testing.T) {
 	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)
@@ -348,7 +347,7 @@ func TestUpdateValidators(t *testing.T) {
 // TestEndBlockValidatorUpdates ensures we update validator set and send an event.
 func TestEndBlockValidatorUpdates(t *testing.T) {
 	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)
@@ -421,7 +420,7 @@ func TestEndBlockValidatorUpdates(t *testing.T) {
 // would result in empty set causes no panic, an error is raised and NextValidators is not updated
 func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) {
 	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	proxyApp := proxy.NewAppConns(cc)
 	err := proxyApp.Start()
 	require.Nil(t, err)

state/helpers_test.go

@@ -7,17 +7,16 @@ import (
 
 	dbm "github.com/tendermint/tm-db"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
-	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/internal/test/factory"
 	tmrand "github.com/tendermint/tendermint/libs/rand"
 	tmtime "github.com/tendermint/tendermint/libs/time"
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+	"github.com/tendermint/tendermint/proxy"
 	sm "github.com/tendermint/tendermint/state"
 	sf "github.com/tendermint/tendermint/state/test/factory"
 	"github.com/tendermint/tendermint/types"
@@ -30,7 +29,7 @@ type paramsChangeTestCase struct {
 
 func newTestApp() proxy.AppConns {
 	app := &testApp{}
-	cc := abciclient.NewLocalCreator(app)
+	cc := proxy.NewLocalClientCreator(app)
 	return proxy.NewAppConns(cc)
 }
 

test/e2e/app/main.go

@@ -14,7 +14,6 @@ import (
 	"github.com/spf13/viper"
 	"google.golang.org/grpc"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/server"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto/ed25519"
@@ -29,6 +28,7 @@ import (
 	"github.com/tendermint/tendermint/privval"
 	grpcprivval "github.com/tendermint/tendermint/privval/grpc"
 	privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval"
+	"github.com/tendermint/tendermint/proxy"
 	rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server"
 	e2e "github.com/tendermint/tendermint/test/e2e/pkg"
 )
@@ -130,7 +130,7 @@ func startNode(cfg *Config) error {
 
 	n, err := node.New(tmcfg,
 		nodeLogger,
-		abciclient.NewLocalCreator(app),
+		proxy.NewLocalClientCreator(app),
 		nil,
 	)
 	if err != nil {

test/e2e/runner/main.go

@@ -52,13 +52,6 @@ func NewCLI() *CLI {
 			if err := Cleanup(cli.testnet); err != nil {
 				return err
 			}
-			defer func() {
-				if cli.preserve {
-					logger.Info("Preserving testnet contents because -preserve=true")
-				} else if err := Cleanup(cli.testnet); err != nil {
-					logger.Error("Error cleaning up testnet contents", "err", err)
-				}
-			}()
 			if err := Setup(cli.testnet); err != nil {
 				return err
 			}
@@ -110,6 +103,11 @@ func NewCLI() *CLI {
 			if err := Test(cli.testnet); err != nil {
 				return err
 			}
+			if !cli.preserve {
+				if err := Cleanup(cli.testnet); err != nil {
+					return err
+				}
+			}
 			return nil
 		},
 	}
@@ -271,12 +269,6 @@ Does not run any perbutations.
 			if err := Cleanup(cli.testnet); err != nil {
 				return err
 			}
-			defer func() {
-				if err := Cleanup(cli.testnet); err != nil {
-					logger.Error("Error cleaning up testnet contents", "err", err)
-				}
-			}()
-
 			if err := Setup(cli.testnet); err != nil {
 				return err
 			}
@@ -310,6 +302,10 @@ Does not run any perbutations.
 				return err
 			}
 
+			if err := Cleanup(cli.testnet); err != nil {
+				return err
+			}
+
 			return nil
 		},
 	})

test/fuzz/mempool/v0/checktx.go

@@ -3,19 +3,19 @@ package v0
 import (
 	"context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/mempool"
 	mempoolv0 "github.com/tendermint/tendermint/internal/mempool/v0"
+	"github.com/tendermint/tendermint/proxy"
 )
 
 var mp mempool.Mempool
 
 func init() {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
-	appConnMem, _ := cc.NewClient()
+	cc := proxy.NewLocalClientCreator(app)
+	appConnMem, _ := cc.NewABCIClient()
 	err := appConnMem.Start()
 	if err != nil {
 		panic(err)

test/fuzz/mempool/v1/checktx.go

@@ -3,19 +3,19 @@ package v1
 import (
 	"context"
 
-	abciclient "github.com/tendermint/tendermint/abci/client"
 	"github.com/tendermint/tendermint/abci/example/kvstore"
 	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/mempool"
 	mempoolv1 "github.com/tendermint/tendermint/internal/mempool/v0"
+	"github.com/tendermint/tendermint/proxy"
 )
 
 var mp mempool.Mempool
 
 func init() {
 	app := kvstore.NewApplication()
-	cc := abciclient.NewLocalCreator(app)
-	appConnMem, _ := cc.NewClient()
+	cc := proxy.NewLocalClientCreator(app)
+	appConnMem, _ := cc.NewABCIClient()
 	err := appConnMem.Start()
 	if err != nil {
 		panic(err)