cleanup: Reduce and normalize import path aliasing. (#6975)

The code in the Tendermint repository makes heavy use of import aliasing.
This is made necessary by our extensive reuse of common base package names, and
by repetition of similar names across different subdirectories.

Unfortunately we have not been very consistent about which packages we alias in
various circumstances, and the aliases we use vary. In the spirit of the advice
in the style guide and https://github.com/golang/go/wiki/CodeReviewComments#imports,
his change makes an effort to clean up and normalize import aliasing.

This change makes no API or behavioral changes. It is a pure cleanup intended
o help make the code more readable to developers (including myself) trying to
understand what is being imported where.

Only unexported names have been modified, and the changes were generated and
applied mechanically with gofmt -r and comby, respecting the lexical and
syntactic rules of Go.  Even so, I did not fix every inconsistency. Where the
changes would be too disruptive, I left it alone.

The principles I followed in this cleanup are:

- Remove aliases that restate the package name.
- Remove aliases where the base package name is unambiguous.
- Move overly-terse abbreviations from the import to the usage site.
- Fix lexical issues (remove underscores, remove capitalization).
- Fix import groupings to more closely match the style guide.
- Group blank (side-effecting) imports and ensure they are commented.
- Add aliases to multiple imports with the same base package name.

internal/rpc/core/abci.go

@@ -4,7 +4,7 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/internal/proxy"
 	"github.com/tendermint/tendermint/libs/bytes"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
 
@@ -16,7 +16,7 @@ func (env *Environment) ABCIQuery(
 	data bytes.HexBytes,
 	height int64,
 	prove bool,
-) (*ctypes.ResultABCIQuery, error) {
+) (*coretypes.ResultABCIQuery, error) {
 	resQuery, err := env.ProxyAppQuery.QuerySync(ctx.Context(), abci.RequestQuery{
 		Path:   path,
 		Data:   data,
@@ -27,16 +27,16 @@ func (env *Environment) ABCIQuery(
 		return nil, err
 	}
 
-	return &ctypes.ResultABCIQuery{Response: *resQuery}, nil
+	return &coretypes.ResultABCIQuery{Response: *resQuery}, nil
 }
 
 // ABCIInfo gets some info about the application.
 // More: https://docs.tendermint.com/master/rpc/#/ABCI/abci_info
-func (env *Environment) ABCIInfo(ctx *rpctypes.Context) (*ctypes.ResultABCIInfo, error) {
+func (env *Environment) ABCIInfo(ctx *rpctypes.Context) (*coretypes.ResultABCIInfo, error) {
 	resInfo, err := env.ProxyAppQuery.InfoSync(ctx.Context(), proxy.RequestInfo)
 	if err != nil {
 		return nil, err
 	}
 
-	return &ctypes.ResultABCIInfo{Response: *resInfo}, nil
+	return &coretypes.ResultABCIInfo{Response: *resInfo}, nil
 }

internal/rpc/core/blocks.go

@@ -8,7 +8,7 @@ import (
 	"github.com/tendermint/tendermint/libs/bytes"
 	tmmath "github.com/tendermint/tendermint/libs/math"
 	tmquery "github.com/tendermint/tendermint/libs/pubsub/query"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	"github.com/tendermint/tendermint/types"
 )
@@ -25,7 +25,7 @@ import (
 // More: https://docs.tendermint.com/master/rpc/#/Info/blockchain
 func (env *Environment) BlockchainInfo(
 	ctx *rpctypes.Context,
-	minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) {
+	minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) {
 
 	const limit int64 = 20
 
@@ -49,7 +49,7 @@ func (env *Environment) BlockchainInfo(
 		}
 	}
 
-	return &ctypes.ResultBlockchainInfo{
+	return &coretypes.ResultBlockchainInfo{
 		LastHeight: env.BlockStore.Height(),
 		BlockMetas: blockMetas}, nil
 }
@@ -60,7 +60,7 @@ func (env *Environment) BlockchainInfo(
 func filterMinMax(base, height, min, max, limit int64) (int64, int64, error) {
 	// filter negatives
 	if min < 0 || max < 0 {
-		return min, max, ctypes.ErrZeroOrNegativeHeight
+		return min, max, coretypes.ErrZeroOrNegativeHeight
 	}
 
 	// adjust for default values
@@ -83,7 +83,7 @@ func filterMinMax(base, height, min, max, limit int64) (int64, int64, error) {
 
 	if min > max {
 		return min, max, fmt.Errorf("%w: min height %d can't be greater than max height %d",
-			ctypes.ErrInvalidRequest, min, max)
+			coretypes.ErrInvalidRequest, min, max)
 	}
 	return min, max, nil
 }
@@ -91,7 +91,7 @@ func filterMinMax(base, height, min, max, limit int64) (int64, int64, error) {
 // Block gets block at a given height.
 // If no height is provided, it will fetch the latest block.
 // More: https://docs.tendermint.com/master/rpc/#/Info/block
-func (env *Environment) Block(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlock, error) {
+func (env *Environment) Block(ctx *rpctypes.Context, heightPtr *int64) (*coretypes.ResultBlock, error) {
 	height, err := env.getHeight(env.BlockStore.Height(), heightPtr)
 	if err != nil {
 		return nil, err
@@ -99,33 +99,33 @@ func (env *Environment) Block(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.
 
 	blockMeta := env.BlockStore.LoadBlockMeta(height)
 	if blockMeta == nil {
-		return &ctypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil
+		return &coretypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil
 	}
 
 	block := env.BlockStore.LoadBlock(height)
-	return &ctypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil
+	return &coretypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil
 }
 
 // BlockByHash gets block by hash.
 // More: https://docs.tendermint.com/master/rpc/#/Info/block_by_hash
-func (env *Environment) BlockByHash(ctx *rpctypes.Context, hash bytes.HexBytes) (*ctypes.ResultBlock, error) {
+func (env *Environment) BlockByHash(ctx *rpctypes.Context, hash bytes.HexBytes) (*coretypes.ResultBlock, error) {
 	// N.B. The hash parameter is HexBytes so that the reflective parameter
 	// decoding logic in the HTTP service will correctly translate from JSON.
 	// See https://github.com/tendermint/tendermint/issues/6802 for context.
 
 	block := env.BlockStore.LoadBlockByHash(hash)
 	if block == nil {
-		return &ctypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil
+		return &coretypes.ResultBlock{BlockID: types.BlockID{}, Block: nil}, nil
 	}
 	// If block is not nil, then blockMeta can't be nil.
 	blockMeta := env.BlockStore.LoadBlockMeta(block.Height)
-	return &ctypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil
+	return &coretypes.ResultBlock{BlockID: blockMeta.BlockID, Block: block}, nil
 }
 
 // Commit gets block commit at a given height.
 // If no height is provided, it will fetch the commit for the latest block.
 // More: https://docs.tendermint.com/master/rpc/#/Info/commit
-func (env *Environment) Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultCommit, error) {
+func (env *Environment) Commit(ctx *rpctypes.Context, heightPtr *int64) (*coretypes.ResultCommit, error) {
 	height, err := env.getHeight(env.BlockStore.Height(), heightPtr)
 	if err != nil {
 		return nil, err
@@ -144,7 +144,7 @@ func (env *Environment) Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes
 		// NOTE: we can't yet ensure atomicity of operations in asserting
 		// whether this is the latest height and retrieving the seen commit
 		if commit != nil && commit.Height == height {
-			return ctypes.NewResultCommit(&header, commit, false), nil
+			return coretypes.NewResultCommit(&header, commit, false), nil
 		}
 	}
 
@@ -153,7 +153,7 @@ func (env *Environment) Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes
 	if commit == nil {
 		return nil, nil
 	}
-	return ctypes.NewResultCommit(&header, commit, true), nil
+	return coretypes.NewResultCommit(&header, commit, true), nil
 }
 
 // BlockResults gets ABCIResults at a given height.
@@ -163,7 +163,7 @@ func (env *Environment) Commit(ctx *rpctypes.Context, heightPtr *int64) (*ctypes
 // Thus response.results.deliver_tx[5] is the results of executing
 // getBlock(h).Txs[5]
 // More: https://docs.tendermint.com/master/rpc/#/Info/block_results
-func (env *Environment) BlockResults(ctx *rpctypes.Context, heightPtr *int64) (*ctypes.ResultBlockResults, error) {
+func (env *Environment) BlockResults(ctx *rpctypes.Context, heightPtr *int64) (*coretypes.ResultBlockResults, error) {
 	height, err := env.getHeight(env.BlockStore.Height(), heightPtr)
 	if err != nil {
 		return nil, err
@@ -179,7 +179,7 @@ func (env *Environment) BlockResults(ctx *rpctypes.Context, heightPtr *int64) (*
 		totalGasUsed += tx.GetGasUsed()
 	}
 
-	return &ctypes.ResultBlockResults{
+	return &coretypes.ResultBlockResults{
 		Height:                height,
 		TxsResults:            results.DeliverTxs,
 		TotalGasUsed:          totalGasUsed,
@@ -197,7 +197,7 @@ func (env *Environment) BlockSearch(
 	query string,
 	pagePtr, perPagePtr *int,
 	orderBy string,
-) (*ctypes.ResultBlockSearch, error) {
+) (*coretypes.ResultBlockSearch, error) {
 
 	if !indexer.KVSinkEnabled(env.EventSinks) {
 		return nil, fmt.Errorf("block searching is disabled due to no kvEventSink")
@@ -229,7 +229,7 @@ func (env *Environment) BlockSearch(
 		sort.Slice(results, func(i, j int) bool { return results[i] < results[j] })
 
 	default:
-		return nil, fmt.Errorf("expected order_by to be either `asc` or `desc` or empty: %w", ctypes.ErrInvalidRequest)
+		return nil, fmt.Errorf("expected order_by to be either `asc` or `desc` or empty: %w", coretypes.ErrInvalidRequest)
 	}
 
 	// paginate results
@@ -244,13 +244,13 @@ func (env *Environment) BlockSearch(
 	skipCount := validateSkipCount(page, perPage)
 	pageSize := tmmath.MinInt(perPage, totalCount-skipCount)
 
-	apiResults := make([]*ctypes.ResultBlock, 0, pageSize)
+	apiResults := make([]*coretypes.ResultBlock, 0, pageSize)
 	for i := skipCount; i < skipCount+pageSize; i++ {
 		block := env.BlockStore.LoadBlock(results[i])
 		if block != nil {
 			blockMeta := env.BlockStore.LoadBlockMeta(block.Height)
 			if blockMeta != nil {
-				apiResults = append(apiResults, &ctypes.ResultBlock{
+				apiResults = append(apiResults, &coretypes.ResultBlock{
 					Block:   block,
 					BlockID: blockMeta.BlockID,
 				})
@@ -258,5 +258,5 @@ func (env *Environment) BlockSearch(
 		}
 	}
 
-	return &ctypes.ResultBlockSearch{Blocks: apiResults, TotalCount: totalCount}, nil
+	return &coretypes.ResultBlockSearch{Blocks: apiResults, TotalCount: totalCount}, nil
 }

internal/rpc/core/blocks_test.go

@@ -12,7 +12,7 @@ import (
 	abci "github.com/tendermint/tendermint/abci/types"
 	sm "github.com/tendermint/tendermint/internal/state"
 	tmstate "github.com/tendermint/tendermint/proto/tendermint/state"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	"github.com/tendermint/tendermint/types"
 )
@@ -89,12 +89,12 @@ func TestBlockResults(t *testing.T) {
 	testCases := []struct {
 		height  int64
 		wantErr bool
-		wantRes *ctypes.ResultBlockResults
+		wantRes *coretypes.ResultBlockResults
 	}{
 		{-1, true, nil},
 		{0, true, nil},
 		{101, true, nil},
-		{100, false, &ctypes.ResultBlockResults{
+		{100, false, &coretypes.ResultBlockResults{
 			Height:                100,
 			TxsResults:            results.DeliverTxs,
 			TotalGasUsed:          15,

internal/rpc/core/consensus.go

@@ -3,9 +3,9 @@ package core
 import (
 	"errors"
 
-	cm "github.com/tendermint/tendermint/internal/consensus"
+	"github.com/tendermint/tendermint/internal/consensus"
 	tmmath "github.com/tendermint/tendermint/libs/math"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	"github.com/tendermint/tendermint/types"
 )
@@ -20,7 +20,7 @@ import (
 func (env *Environment) Validators(
 	ctx *rpctypes.Context,
 	heightPtr *int64,
-	pagePtr, perPagePtr *int) (*ctypes.ResultValidators, error) {
+	pagePtr, perPagePtr *int) (*coretypes.ResultValidators, error) {
 
 	// The latest validator that we know is the NextValidator of the last block.
 	height, err := env.getHeight(env.latestUncommittedHeight(), heightPtr)
@@ -44,7 +44,7 @@ func (env *Environment) Validators(
 
 	v := validators.Validators[skipCount : skipCount+tmmath.MinInt(perPage, totalCount-skipCount)]
 
-	return &ctypes.ResultValidators{
+	return &coretypes.ResultValidators{
 		BlockHeight: height,
 		Validators:  v,
 		Count:       len(v),
@@ -54,16 +54,16 @@ func (env *Environment) Validators(
 // DumpConsensusState dumps consensus state.
 // UNSTABLE
 // More: https://docs.tendermint.com/master/rpc/#/Info/dump_consensus_state
-func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState, error) {
+func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*coretypes.ResultDumpConsensusState, error) {
 	// Get Peer consensus states.
 
-	var peerStates []ctypes.PeerStateInfo
+	var peerStates []coretypes.PeerStateInfo
 	switch {
 	case env.P2PPeers != nil:
 		peers := env.P2PPeers.Peers().List()
-		peerStates = make([]ctypes.PeerStateInfo, 0, len(peers))
+		peerStates = make([]coretypes.PeerStateInfo, 0, len(peers))
 		for _, peer := range peers {
-			peerState, ok := peer.Get(types.PeerStateKey).(*cm.PeerState)
+			peerState, ok := peer.Get(types.PeerStateKey).(*consensus.PeerState)
 			if !ok { // peer does not have a state yet
 				continue
 			}
@@ -71,7 +71,7 @@ func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*ctypes.Resul
 			if err != nil {
 				return nil, err
 			}
-			peerStates = append(peerStates, ctypes.PeerStateInfo{
+			peerStates = append(peerStates, coretypes.PeerStateInfo{
 				// Peer basic info.
 				NodeAddress: peer.SocketAddr().String(),
 				// Peer consensus state.
@@ -80,7 +80,7 @@ func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*ctypes.Resul
 		}
 	case env.PeerManager != nil:
 		peers := env.PeerManager.Peers()
-		peerStates = make([]ctypes.PeerStateInfo, 0, len(peers))
+		peerStates = make([]coretypes.PeerStateInfo, 0, len(peers))
 		for _, pid := range peers {
 			peerState, ok := env.ConsensusReactor.GetPeerState(pid)
 			if !ok {
@@ -94,7 +94,7 @@ func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*ctypes.Resul
 
 			addr := env.PeerManager.Addresses(pid)
 			if len(addr) >= 1 {
-				peerStates = append(peerStates, ctypes.PeerStateInfo{
+				peerStates = append(peerStates, coretypes.PeerStateInfo{
 					// Peer basic info.
 					NodeAddress: addr[0].String(),
 					// Peer consensus state.
@@ -111,7 +111,7 @@ func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*ctypes.Resul
 	if err != nil {
 		return nil, err
 	}
-	return &ctypes.ResultDumpConsensusState{
+	return &coretypes.ResultDumpConsensusState{
 		RoundState: roundState,
 		Peers:      peerStates}, nil
 }
@@ -119,10 +119,10 @@ func (env *Environment) DumpConsensusState(ctx *rpctypes.Context) (*ctypes.Resul
 // ConsensusState returns a concise summary of the consensus state.
 // UNSTABLE
 // More: https://docs.tendermint.com/master/rpc/#/Info/consensus_state
-func (env *Environment) GetConsensusState(ctx *rpctypes.Context) (*ctypes.ResultConsensusState, error) {
+func (env *Environment) GetConsensusState(ctx *rpctypes.Context) (*coretypes.ResultConsensusState, error) {
 	// Get self round state.
 	bz, err := env.ConsensusState.GetRoundStateSimpleJSON()
-	return &ctypes.ResultConsensusState{RoundState: bz}, err
+	return &coretypes.ResultConsensusState{RoundState: bz}, err
 }
 
 // ConsensusParams gets the consensus parameters at the given block height.
@@ -130,7 +130,7 @@ func (env *Environment) GetConsensusState(ctx *rpctypes.Context) (*ctypes.Result
 // More: https://docs.tendermint.com/master/rpc/#/Info/consensus_params
 func (env *Environment) ConsensusParams(
 	ctx *rpctypes.Context,
-	heightPtr *int64) (*ctypes.ResultConsensusParams, error) {
+	heightPtr *int64) (*coretypes.ResultConsensusParams, error) {
 
 	// The latest consensus params that we know is the consensus params after the
 	// last block.
@@ -144,7 +144,7 @@ func (env *Environment) ConsensusParams(
 		return nil, err
 	}
 
-	return &ctypes.ResultConsensusParams{
+	return &coretypes.ResultConsensusParams{
 		BlockHeight:     height,
 		ConsensusParams: consensusParams}, nil
 }

internal/rpc/core/dev.go

@@ -1,12 +1,12 @@
 package core
 
 import (
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
 
 // UnsafeFlushMempool removes all transactions from the mempool.
-func (env *Environment) UnsafeFlushMempool(ctx *rpctypes.Context) (*ctypes.ResultUnsafeFlushMempool, error) {
+func (env *Environment) UnsafeFlushMempool(ctx *rpctypes.Context) (*coretypes.ResultUnsafeFlushMempool, error) {
 	env.Mempool.Flush()
-	return &ctypes.ResultUnsafeFlushMempool{}, nil
+	return &coretypes.ResultUnsafeFlushMempool{}, nil
 }

internal/rpc/core/env.go

@@ -5,10 +5,10 @@ import (
 	"fmt"
 	"time"
 
-	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/internal/consensus"
-	mempl "github.com/tendermint/tendermint/internal/mempool"
+	"github.com/tendermint/tendermint/internal/mempool"
 	"github.com/tendermint/tendermint/internal/p2p"
 	"github.com/tendermint/tendermint/internal/proxy"
 	sm "github.com/tendermint/tendermint/internal/state"
@@ -16,7 +16,7 @@ import (
 	"github.com/tendermint/tendermint/internal/statesync"
 	tmjson "github.com/tendermint/tendermint/libs/json"
 	"github.com/tendermint/tendermint/libs/log"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -96,13 +96,13 @@ type Environment struct {
 	GenDoc            *types.GenesisDoc // cache the genesis structure
 	EventSinks        []indexer.EventSink
 	EventBus          *types.EventBus // thread safe
-	Mempool           mempl.Mempool
+	Mempool           mempool.Mempool
 	BlockSyncReactor  consensus.BlockSyncReactor
 	StateSyncMetricer statesync.Metricer
 
 	Logger log.Logger
 
-	Config cfg.RPCConfig
+	Config config.RPCConfig
 
 	// cache of chunked genesis data.
 	genChunks []string
@@ -113,7 +113,7 @@ type Environment struct {
 func validatePage(pagePtr *int, perPage, totalCount int) (int, error) {
 	// this can only happen if we haven't first run validatePerPage
 	if perPage < 1 {
-		panic(fmt.Errorf("%w (%d)", ctypes.ErrZeroOrNegativePerPage, perPage))
+		panic(fmt.Errorf("%w (%d)", coretypes.ErrZeroOrNegativePerPage, perPage))
 	}
 
 	if pagePtr == nil { // no page parameter
@@ -126,7 +126,7 @@ func validatePage(pagePtr *int, perPage, totalCount int) (int, error) {
 	}
 	page := *pagePtr
 	if page <= 0 || page > pages {
-		return 1, fmt.Errorf("%w expected range: [1, %d], given %d", ctypes.ErrPageOutOfRange, pages, page)
+		return 1, fmt.Errorf("%w expected range: [1, %d], given %d", coretypes.ErrPageOutOfRange, pages, page)
 	}
 
 	return page, nil
@@ -191,15 +191,15 @@ func (env *Environment) getHeight(latestHeight int64, heightPtr *int64) (int64,
 	if heightPtr != nil {
 		height := *heightPtr
 		if height <= 0 {
-			return 0, fmt.Errorf("%w (requested height: %d)", ctypes.ErrZeroOrNegativeHeight, height)
+			return 0, fmt.Errorf("%w (requested height: %d)", coretypes.ErrZeroOrNegativeHeight, height)
 		}
 		if height > latestHeight {
 			return 0, fmt.Errorf("%w (requested height: %d, blockchain height: %d)",
-				ctypes.ErrHeightExceedsChainHead, height, latestHeight)
+				coretypes.ErrHeightExceedsChainHead, height, latestHeight)
 		}
 		base := env.BlockStore.Base()
 		if height < base {
-			return 0, fmt.Errorf("%w (requested height: %d, base height: %d)", ctypes.ErrHeightNotAvailable, height, base)
+			return 0, fmt.Errorf("%w (requested height: %d, base height: %d)", coretypes.ErrHeightNotAvailable, height, base)
 		}
 		return height, nil
 	}

internal/rpc/core/events.go

@@ -7,7 +7,7 @@ import (
 
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
 	tmquery "github.com/tendermint/tendermint/libs/pubsub/query"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
 
@@ -18,7 +18,7 @@ const (
 
 // Subscribe for events via WebSocket.
 // More: https://docs.tendermint.com/master/rpc/#/Websocket/subscribe
-func (env *Environment) Subscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, error) {
+func (env *Environment) Subscribe(ctx *rpctypes.Context, query string) (*coretypes.ResultSubscribe, error) {
 	addr := ctx.RemoteAddr()
 
 	if env.EventBus.NumClients() >= env.Config.MaxSubscriptionClients {
@@ -49,7 +49,7 @@ func (env *Environment) Subscribe(ctx *rpctypes.Context, query string) (*ctypes.
 			select {
 			case msg := <-sub.Out():
 				var (
-					resultEvent = &ctypes.ResultEvent{Query: query, Data: msg.Data(), Events: msg.Events()}
+					resultEvent = &coretypes.ResultEvent{Query: query, Data: msg.Data(), Events: msg.Events()}
 					resp        = rpctypes.NewRPCSuccessResponse(subscriptionID, resultEvent)
 				)
 				writeCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@@ -80,12 +80,12 @@ func (env *Environment) Subscribe(ctx *rpctypes.Context, query string) (*ctypes.
 		}
 	}()
 
-	return &ctypes.ResultSubscribe{}, nil
+	return &coretypes.ResultSubscribe{}, nil
 }
 
 // Unsubscribe from events via WebSocket.
 // More: https://docs.tendermint.com/master/rpc/#/Websocket/unsubscribe
-func (env *Environment) Unsubscribe(ctx *rpctypes.Context, query string) (*ctypes.ResultUnsubscribe, error) {
+func (env *Environment) Unsubscribe(ctx *rpctypes.Context, query string) (*coretypes.ResultUnsubscribe, error) {
 	args := tmpubsub.UnsubscribeArgs{Subscriber: ctx.RemoteAddr()}
 	env.Logger.Info("Unsubscribe from query", "remote", args.Subscriber, "subscription", query)
 
@@ -100,17 +100,17 @@ func (env *Environment) Unsubscribe(ctx *rpctypes.Context, query string) (*ctype
 	if err != nil {
 		return nil, err
 	}
-	return &ctypes.ResultUnsubscribe{}, nil
+	return &coretypes.ResultUnsubscribe{}, nil
 }
 
 // UnsubscribeAll from all events via WebSocket.
 // More: https://docs.tendermint.com/master/rpc/#/Websocket/unsubscribe_all
-func (env *Environment) UnsubscribeAll(ctx *rpctypes.Context) (*ctypes.ResultUnsubscribe, error) {
+func (env *Environment) UnsubscribeAll(ctx *rpctypes.Context) (*coretypes.ResultUnsubscribe, error) {
 	addr := ctx.RemoteAddr()
 	env.Logger.Info("Unsubscribe from all", "remote", addr)
 	err := env.EventBus.UnsubscribeAll(ctx.Context(), addr)
 	if err != nil {
 		return nil, err
 	}
-	return &ctypes.ResultUnsubscribe{}, nil
+	return &coretypes.ResultUnsubscribe{}, nil
 }

internal/rpc/core/evidence.go

@@ -3,7 +3,7 @@ package core
 import (
 	"fmt"
 
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	"github.com/tendermint/tendermint/types"
 )
@@ -12,10 +12,10 @@ import (
 // More: https://docs.tendermint.com/master/rpc/#/Evidence/broadcast_evidence
 func (env *Environment) BroadcastEvidence(
 	ctx *rpctypes.Context,
-	ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) {
+	ev types.Evidence) (*coretypes.ResultBroadcastEvidence, error) {
 
 	if ev == nil {
-		return nil, fmt.Errorf("%w: no evidence was provided", ctypes.ErrInvalidRequest)
+		return nil, fmt.Errorf("%w: no evidence was provided", coretypes.ErrInvalidRequest)
 	}
 
 	if err := ev.ValidateBasic(); err != nil {
@@ -25,5 +25,5 @@ func (env *Environment) BroadcastEvidence(
 	if err := env.EvidencePool.AddEvidence(ev); err != nil {
 		return nil, fmt.Errorf("failed to add evidence: %w", err)
 	}
-	return &ctypes.ResultBroadcastEvidence{Hash: ev.Hash()}, nil
+	return &coretypes.ResultBroadcastEvidence{Hash: ev.Hash()}, nil
 }

internal/rpc/core/health.go

@@ -1,13 +1,13 @@
 package core
 
 import (
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
 
 // Health gets node health. Returns empty result (200 OK) on success, no
 // response - in case of an error.
 // More: https://docs.tendermint.com/master/rpc/#/Info/health
-func (env *Environment) Health(ctx *rpctypes.Context) (*ctypes.ResultHealth, error) {
-	return &ctypes.ResultHealth{}, nil
+func (env *Environment) Health(ctx *rpctypes.Context) (*coretypes.ResultHealth, error) {
+	return &coretypes.ResultHealth{}, nil
 }

internal/rpc/core/mempool.go

@@ -7,9 +7,9 @@ import (
 	"time"
 
 	abci "github.com/tendermint/tendermint/abci/types"
-	mempl "github.com/tendermint/tendermint/internal/mempool"
+	"github.com/tendermint/tendermint/internal/mempool"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	"github.com/tendermint/tendermint/types"
 )
@@ -20,25 +20,25 @@ import (
 // BroadcastTxAsync returns right away, with no response. Does not wait for
 // CheckTx nor DeliverTx results.
 // More: https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
-func (env *Environment) BroadcastTxAsync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
-	err := env.Mempool.CheckTx(ctx.Context(), tx, nil, mempl.TxInfo{})
+func (env *Environment) BroadcastTxAsync(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) {
+	err := env.Mempool.CheckTx(ctx.Context(), tx, nil, mempool.TxInfo{})
 	if err != nil {
 		return nil, err
 	}
 
-	return &ctypes.ResultBroadcastTx{Hash: tx.Hash()}, nil
+	return &coretypes.ResultBroadcastTx{Hash: tx.Hash()}, nil
 }
 
 // BroadcastTxSync returns with the response from CheckTx. Does not wait for
 // DeliverTx result.
 // More: https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
-func (env *Environment) BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) {
+func (env *Environment) BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) {
 	resCh := make(chan *abci.Response, 1)
 	err := env.Mempool.CheckTx(
 		ctx.Context(),
 		tx,
 		func(res *abci.Response) { resCh <- res },
-		mempl.TxInfo{},
+		mempool.TxInfo{},
 	)
 	if err != nil {
 		return nil, err
@@ -47,7 +47,7 @@ func (env *Environment) BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*ct
 	res := <-resCh
 	r := res.GetCheckTx()
 
-	return &ctypes.ResultBroadcastTx{
+	return &coretypes.ResultBroadcastTx{
 		Code:         r.Code,
 		Data:         r.Data,
 		Log:          r.Log,
@@ -59,7 +59,7 @@ func (env *Environment) BroadcastTxSync(ctx *rpctypes.Context, tx types.Tx) (*ct
 
 // BroadcastTxCommit returns with the responses from CheckTx and DeliverTx.
 // More: https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
-func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
+func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { //nolint:lll
 	subscriber := ctx.RemoteAddr()
 
 	if env.EventBus.NumClients() >= env.Config.MaxSubscriptionClients {
@@ -91,7 +91,7 @@ func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*
 		ctx.Context(),
 		tx,
 		func(res *abci.Response) { checkTxResCh <- res },
-		mempl.TxInfo{},
+		mempool.TxInfo{},
 	)
 	if err != nil {
 		env.Logger.Error("Error on broadcastTxCommit", "err", err)
@@ -102,7 +102,7 @@ func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*
 	checkTxRes := checkTxResMsg.GetCheckTx()
 
 	if checkTxRes.Code != abci.CodeTypeOK {
-		return &ctypes.ResultBroadcastTxCommit{
+		return &coretypes.ResultBroadcastTxCommit{
 			CheckTx:   *checkTxRes,
 			DeliverTx: abci.ResponseDeliverTx{},
 			Hash:      tx.Hash(),
@@ -113,7 +113,7 @@ func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*
 	select {
 	case msg := <-deliverTxSub.Out(): // The tx was included in a block.
 		deliverTxRes := msg.Data().(types.EventDataTx)
-		return &ctypes.ResultBroadcastTxCommit{
+		return &coretypes.ResultBroadcastTxCommit{
 			CheckTx:   *checkTxRes,
 			DeliverTx: deliverTxRes.Result,
 			Hash:      tx.Hash(),
@@ -128,7 +128,7 @@ func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*
 		}
 		err = fmt.Errorf("deliverTxSub was canceled (reason: %s)", reason)
 		env.Logger.Error("Error on broadcastTxCommit", "err", err)
-		return &ctypes.ResultBroadcastTxCommit{
+		return &coretypes.ResultBroadcastTxCommit{
 			CheckTx:   *checkTxRes,
 			DeliverTx: abci.ResponseDeliverTx{},
 			Hash:      tx.Hash(),
@@ -136,7 +136,7 @@ func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*
 	case <-time.After(env.Config.TimeoutBroadcastTxCommit):
 		err = errors.New("timed out waiting for tx to be included in a block")
 		env.Logger.Error("Error on broadcastTxCommit", "err", err)
-		return &ctypes.ResultBroadcastTxCommit{
+		return &coretypes.ResultBroadcastTxCommit{
 			CheckTx:   *checkTxRes,
 			DeliverTx: abci.ResponseDeliverTx{},
 			Hash:      tx.Hash(),
@@ -147,12 +147,12 @@ func (env *Environment) BroadcastTxCommit(ctx *rpctypes.Context, tx types.Tx) (*
 // UnconfirmedTxs gets unconfirmed transactions (maximum ?limit entries)
 // including their number.
 // More: https://docs.tendermint.com/master/rpc/#/Info/unconfirmed_txs
-func (env *Environment) UnconfirmedTxs(ctx *rpctypes.Context, limitPtr *int) (*ctypes.ResultUnconfirmedTxs, error) {
+func (env *Environment) UnconfirmedTxs(ctx *rpctypes.Context, limitPtr *int) (*coretypes.ResultUnconfirmedTxs, error) {
 	// reuse per_page validator
 	limit := env.validatePerPage(limitPtr)
 
 	txs := env.Mempool.ReapMaxTxs(limit)
-	return &ctypes.ResultUnconfirmedTxs{
+	return &coretypes.ResultUnconfirmedTxs{
 		Count:      len(txs),
 		Total:      env.Mempool.Size(),
 		TotalBytes: env.Mempool.SizeBytes(),
@@ -161,8 +161,8 @@ func (env *Environment) UnconfirmedTxs(ctx *rpctypes.Context, limitPtr *int) (*c
 
 // NumUnconfirmedTxs gets number of unconfirmed transactions.
 // More: https://docs.tendermint.com/master/rpc/#/Info/num_unconfirmed_txs
-func (env *Environment) NumUnconfirmedTxs(ctx *rpctypes.Context) (*ctypes.ResultUnconfirmedTxs, error) {
-	return &ctypes.ResultUnconfirmedTxs{
+func (env *Environment) NumUnconfirmedTxs(ctx *rpctypes.Context) (*coretypes.ResultUnconfirmedTxs, error) {
+	return &coretypes.ResultUnconfirmedTxs{
 		Count:      env.Mempool.Size(),
 		Total:      env.Mempool.Size(),
 		TotalBytes: env.Mempool.SizeBytes()}, nil
@@ -171,10 +171,10 @@ func (env *Environment) NumUnconfirmedTxs(ctx *rpctypes.Context) (*ctypes.Result
 // CheckTx checks the transaction without executing it. The transaction won't
 // be added to the mempool either.
 // More: https://docs.tendermint.com/master/rpc/#/Tx/check_tx
-func (env *Environment) CheckTx(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultCheckTx, error) {
+func (env *Environment) CheckTx(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultCheckTx, error) {
 	res, err := env.ProxyAppMempool.CheckTxSync(ctx.Context(), abci.RequestCheckTx{Tx: tx})
 	if err != nil {
 		return nil, err
 	}
-	return &ctypes.ResultCheckTx{ResponseCheckTx: *res}, nil
+	return &coretypes.ResultCheckTx{ResponseCheckTx: *res}, nil
 }

internal/rpc/core/net.go

@@ -6,21 +6,21 @@ import (
 	"strings"
 
 	"github.com/tendermint/tendermint/internal/p2p"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
 
 // NetInfo returns network info.
 // More: https://docs.tendermint.com/master/rpc/#/Info/net_info
-func (env *Environment) NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) {
-	var peers []ctypes.Peer
+func (env *Environment) NetInfo(ctx *rpctypes.Context) (*coretypes.ResultNetInfo, error) {
+	var peers []coretypes.Peer
 
 	switch {
 	case env.P2PPeers != nil:
 		peersList := env.P2PPeers.Peers().List()
-		peers = make([]ctypes.Peer, 0, len(peersList))
+		peers = make([]coretypes.Peer, 0, len(peersList))
 		for _, peer := range peersList {
-			peers = append(peers, ctypes.Peer{
+			peers = append(peers, coretypes.Peer{
 				ID:  peer.ID(),
 				URL: peer.SocketAddr().String(),
 			})
@@ -33,7 +33,7 @@ func (env *Environment) NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, e
 				continue
 			}
 
-			peers = append(peers, ctypes.Peer{
+			peers = append(peers, coretypes.Peer{
 				ID:  peer,
 				URL: addrs[0].String(),
 			})
@@ -42,7 +42,7 @@ func (env *Environment) NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, e
 		return nil, errors.New("peer management system does not support NetInfo responses")
 	}
 
-	return &ctypes.ResultNetInfo{
+	return &coretypes.ResultNetInfo{
 		Listening: env.P2PTransport.IsListening(),
 		Listeners: env.P2PTransport.Listeners(),
 		NPeers:    len(peers),
@@ -51,19 +51,19 @@ func (env *Environment) NetInfo(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, e
 }
 
 // UnsafeDialSeeds dials the given seeds (comma-separated id@IP:PORT).
-func (env *Environment) UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*ctypes.ResultDialSeeds, error) {
+func (env *Environment) UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (*coretypes.ResultDialSeeds, error) {
 	if env.P2PPeers == nil {
 		return nil, errors.New("peer management system does not support this operation")
 	}
 
 	if len(seeds) == 0 {
-		return &ctypes.ResultDialSeeds{}, fmt.Errorf("%w: no seeds provided", ctypes.ErrInvalidRequest)
+		return &coretypes.ResultDialSeeds{}, fmt.Errorf("%w: no seeds provided", coretypes.ErrInvalidRequest)
 	}
 	env.Logger.Info("DialSeeds", "seeds", seeds)
 	if err := env.P2PPeers.DialPeersAsync(seeds); err != nil {
-		return &ctypes.ResultDialSeeds{}, err
+		return &coretypes.ResultDialSeeds{}, err
 	}
-	return &ctypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil
+	return &coretypes.ResultDialSeeds{Log: "Dialing seeds in progress. See /net_info for details"}, nil
 }
 
 // UnsafeDialPeers dials the given peers (comma-separated id@IP:PORT),
@@ -71,19 +71,19 @@ func (env *Environment) UnsafeDialSeeds(ctx *rpctypes.Context, seeds []string) (
 func (env *Environment) UnsafeDialPeers(
 	ctx *rpctypes.Context,
 	peers []string,
-	persistent, unconditional, private bool) (*ctypes.ResultDialPeers, error) {
+	persistent, unconditional, private bool) (*coretypes.ResultDialPeers, error) {
 
 	if env.P2PPeers == nil {
 		return nil, errors.New("peer management system does not support this operation")
 	}
 
 	if len(peers) == 0 {
-		return &ctypes.ResultDialPeers{}, fmt.Errorf("%w: no peers provided", ctypes.ErrInvalidRequest)
+		return &coretypes.ResultDialPeers{}, fmt.Errorf("%w: no peers provided", coretypes.ErrInvalidRequest)
 	}
 
 	ids, err := getIDs(peers)
 	if err != nil {
-		return &ctypes.ResultDialPeers{}, err
+		return &coretypes.ResultDialPeers{}, err
 	}
 
 	env.Logger.Info("DialPeers", "peers", peers, "persistent",
@@ -91,40 +91,40 @@ func (env *Environment) UnsafeDialPeers(
 
 	if persistent {
 		if err := env.P2PPeers.AddPersistentPeers(peers); err != nil {
-			return &ctypes.ResultDialPeers{}, err
+			return &coretypes.ResultDialPeers{}, err
 		}
 	}
 
 	if private {
 		if err := env.P2PPeers.AddPrivatePeerIDs(ids); err != nil {
-			return &ctypes.ResultDialPeers{}, err
+			return &coretypes.ResultDialPeers{}, err
 		}
 	}
 
 	if unconditional {
 		if err := env.P2PPeers.AddUnconditionalPeerIDs(ids); err != nil {
-			return &ctypes.ResultDialPeers{}, err
+			return &coretypes.ResultDialPeers{}, err
 		}
 	}
 
 	if err := env.P2PPeers.DialPeersAsync(peers); err != nil {
-		return &ctypes.ResultDialPeers{}, err
+		return &coretypes.ResultDialPeers{}, err
 	}
 
-	return &ctypes.ResultDialPeers{Log: "Dialing peers in progress. See /net_info for details"}, nil
+	return &coretypes.ResultDialPeers{Log: "Dialing peers in progress. See /net_info for details"}, nil
 }
 
 // Genesis returns genesis file.
 // More: https://docs.tendermint.com/master/rpc/#/Info/genesis
-func (env *Environment) Genesis(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error) {
+func (env *Environment) Genesis(ctx *rpctypes.Context) (*coretypes.ResultGenesis, error) {
 	if len(env.genChunks) > 1 {
 		return nil, errors.New("genesis response is large, please use the genesis_chunked API instead")
 	}
 
-	return &ctypes.ResultGenesis{Genesis: env.GenDoc}, nil
+	return &coretypes.ResultGenesis{Genesis: env.GenDoc}, nil
 }
 
-func (env *Environment) GenesisChunked(ctx *rpctypes.Context, chunk uint) (*ctypes.ResultGenesisChunk, error) {
+func (env *Environment) GenesisChunked(ctx *rpctypes.Context, chunk uint) (*coretypes.ResultGenesisChunk, error) {
 	if env.genChunks == nil {
 		return nil, fmt.Errorf("service configuration error, genesis chunks are not initialized")
 	}
@@ -139,7 +139,7 @@ func (env *Environment) GenesisChunked(ctx *rpctypes.Context, chunk uint) (*ctyp
 		return nil, fmt.Errorf("there are %d chunks, %d is invalid", len(env.genChunks)-1, id)
 	}
 
-	return &ctypes.ResultGenesisChunk{
+	return &coretypes.ResultGenesisChunk{
 		TotalChunks: len(env.genChunks),
 		ChunkNumber: id,
 		Data:        env.genChunks[id],

internal/rpc/core/net_test.go

@@ -6,14 +6,14 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	cfg "github.com/tendermint/tendermint/config"
+	"github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/internal/p2p"
 	"github.com/tendermint/tendermint/libs/log"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 )
 
 func TestUnsafeDialSeeds(t *testing.T) {
-	sw := p2p.MakeSwitch(cfg.DefaultP2PConfig(), 1, "testing", "123.123.123",
+	sw := p2p.MakeSwitch(config.DefaultP2PConfig(), 1, "testing", "123.123.123",
 		func(n int, sw *p2p.Switch) *p2p.Switch { return sw }, log.TestingLogger())
 	err := sw.Start()
 	require.NoError(t, err)
@@ -48,7 +48,7 @@ func TestUnsafeDialSeeds(t *testing.T) {
 }
 
 func TestUnsafeDialPeers(t *testing.T) {
-	sw := p2p.MakeSwitch(cfg.DefaultP2PConfig(), 1, "testing", "123.123.123",
+	sw := p2p.MakeSwitch(config.DefaultP2PConfig(), 1, "testing", "123.123.123",
 		func(n int, sw *p2p.Switch) *p2p.Switch { return sw }, log.TestingLogger())
 	sw.SetAddrBook(&p2p.AddrBookMock{
 		Addrs:        make(map[string]struct{}),

internal/rpc/core/status.go

@@ -5,7 +5,7 @@ import (
 	"time"
 
 	tmbytes "github.com/tendermint/tendermint/libs/bytes"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	"github.com/tendermint/tendermint/types"
 )
@@ -13,7 +13,7 @@ import (
 // Status returns Tendermint status including node info, pubkey, latest block
 // hash, app hash, block height, current max peer block height, and time.
 // More: https://docs.tendermint.com/master/rpc/#/Info/status
-func (env *Environment) Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) {
+func (env *Environment) Status(ctx *rpctypes.Context) (*coretypes.ResultStatus, error) {
 	var (
 		earliestBlockHeight   int64
 		earliestBlockHash     tmbytes.HexBytes
@@ -50,17 +50,17 @@ func (env *Environment) Status(ctx *rpctypes.Context) (*ctypes.ResultStatus, err
 	if val := env.validatorAtHeight(env.latestUncommittedHeight()); val != nil {
 		votingPower = val.VotingPower
 	}
-	validatorInfo := ctypes.ValidatorInfo{}
+	validatorInfo := coretypes.ValidatorInfo{}
 	if env.PubKey != nil {
-		validatorInfo = ctypes.ValidatorInfo{
+		validatorInfo = coretypes.ValidatorInfo{
 			Address:     env.PubKey.Address(),
 			PubKey:      env.PubKey,
 			VotingPower: votingPower,
 		}
 	}
-	result := &ctypes.ResultStatus{
+	result := &coretypes.ResultStatus{
 		NodeInfo: env.P2PTransport.NodeInfo(),
-		SyncInfo: ctypes.SyncInfo{
+		SyncInfo: coretypes.SyncInfo{
 			LatestBlockHash:     latestBlockHash,
 			LatestAppHash:       latestAppHash,
 			LatestBlockHeight:   latestHeight,

internal/rpc/core/tx.go

@@ -9,7 +9,7 @@ import (
 	"github.com/tendermint/tendermint/libs/bytes"
 	tmmath "github.com/tendermint/tendermint/libs/math"
 	tmquery "github.com/tendermint/tendermint/libs/pubsub/query"
-	ctypes "github.com/tendermint/tendermint/rpc/coretypes"
+	"github.com/tendermint/tendermint/rpc/coretypes"
 	rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types"
 	"github.com/tendermint/tendermint/types"
 )
@@ -18,7 +18,7 @@ import (
 // transaction is in the mempool, invalidated, or was not sent in the first
 // place.
 // More: https://docs.tendermint.com/master/rpc/#/Info/tx
-func (env *Environment) Tx(ctx *rpctypes.Context, hash bytes.HexBytes, prove bool) (*ctypes.ResultTx, error) {
+func (env *Environment) Tx(ctx *rpctypes.Context, hash bytes.HexBytes, prove bool) (*coretypes.ResultTx, error) {
 	// if index is disabled, return error
 
 	// N.B. The hash parameter is HexBytes so that the reflective parameter
@@ -45,7 +45,7 @@ func (env *Environment) Tx(ctx *rpctypes.Context, hash bytes.HexBytes, prove boo
 				proof = block.Data.Txs.Proof(int(index)) // XXX: overflow on 32-bit machines
 			}
 
-			return &ctypes.ResultTx{
+			return &coretypes.ResultTx{
 				Hash:     hash,
 				Height:   height,
 				Index:    index,
@@ -68,7 +68,7 @@ func (env *Environment) TxSearch(
 	prove bool,
 	pagePtr, perPagePtr *int,
 	orderBy string,
-) (*ctypes.ResultTxSearch, error) {
+) (*coretypes.ResultTxSearch, error) {
 
 	if !indexer.KVSinkEnabled(env.EventSinks) {
 		return nil, fmt.Errorf("transaction searching is disabled due to no kvEventSink")
@@ -103,7 +103,7 @@ func (env *Environment) TxSearch(
 					return results[i].Height < results[j].Height
 				})
 			default:
-				return nil, fmt.Errorf("expected order_by to be either `asc` or `desc` or empty: %w", ctypes.ErrInvalidRequest)
+				return nil, fmt.Errorf("expected order_by to be either `asc` or `desc` or empty: %w", coretypes.ErrInvalidRequest)
 			}
 
 			// paginate results
@@ -118,7 +118,7 @@ func (env *Environment) TxSearch(
 			skipCount := validateSkipCount(page, perPage)
 			pageSize := tmmath.MinInt(perPage, totalCount-skipCount)
 
-			apiResults := make([]*ctypes.ResultTx, 0, pageSize)
+			apiResults := make([]*coretypes.ResultTx, 0, pageSize)
 			for i := skipCount; i < skipCount+pageSize; i++ {
 				r := results[i]
 
@@ -128,7 +128,7 @@ func (env *Environment) TxSearch(
 					proof = block.Data.Txs.Proof(int(r.Index)) // XXX: overflow on 32-bit machines
 				}
 
-				apiResults = append(apiResults, &ctypes.ResultTx{
+				apiResults = append(apiResults, &coretypes.ResultTx{
 					Hash:     types.Tx(r.Tx).Hash(),
 					Height:   r.Height,
 					Index:    r.Index,
@@ -138,7 +138,7 @@ func (env *Environment) TxSearch(
 				})
 			}
 
-			return &ctypes.ResultTxSearch{Txs: apiResults, TotalCount: totalCount}, nil
+			return &coretypes.ResultTxSearch{Txs: apiResults, TotalCount: totalCount}, nil
 		}
 	}