From cf7537ea5f8306c60df4e5dab39e0686d390117a Mon Sep 17 00:00:00 2001 From: "M. J. Fromberger" Date: Thu, 23 Sep 2021 07:52:07 -0700 Subject: [PATCH] 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. --- abci/example/kvstore/persistent_kvstore.go | 14 +- abci/types/pubkey.go | 8 +- cmd/tendermint/commands/debug/dump.go | 8 +- cmd/tendermint/commands/debug/kill.go | 6 +- cmd/tendermint/commands/debug/util.go | 4 +- cmd/tendermint/commands/light.go | 1 - cmd/tendermint/commands/reindex_event.go | 19 +- cmd/tendermint/main.go | 8 +- config/db.go | 11 +- crypto/encoding/codec.go | 32 +-- crypto/secp256k1/secp256k1_test.go | 3 +- crypto/xchacha20poly1305/xchachapoly_test.go | 22 +- internal/blocksync/v0/reactor.go | 16 +- internal/blocksync/v0/reactor_test.go | 34 +-- internal/blocksync/v2/processor.go | 10 +- internal/blocksync/v2/processor_context.go | 6 +- internal/blocksync/v2/processor_test.go | 10 +- internal/blocksync/v2/reactor.go | 12 +- internal/blocksync/v2/reactor_test.go | 18 +- internal/consensus/byzantine_test.go | 3 +- internal/consensus/common_test.go | 72 +++--- internal/consensus/mempool_test.go | 11 +- internal/consensus/reactor_test.go | 44 ++-- internal/consensus/replay_file.go | 18 +- internal/consensus/replay_stubs.go | 10 +- internal/consensus/replay_test.go | 116 ++++----- internal/consensus/state.go | 8 +- .../consensus/types/height_vote_set_test.go | 12 +- internal/consensus/wal_generator.go | 22 +- internal/evidence/verify_test.go | 1 - internal/mempool/mock/mempool.go | 10 +- internal/mempool/v0/clist_mempool.go | 12 +- internal/mempool/v0/clist_mempool_test.go | 24 +- internal/mempool/v0/reactor.go | 16 +- internal/mempool/v0/reactor_test.go | 34 +-- internal/mempool/v1/reactor.go | 16 +- .../p2p/conn/evil_secret_connection_test.go | 4 +- internal/p2p/conn/secret_connection.go | 6 +- internal/p2p/peermanager_scoring_test.go | 3 +- internal/p2p/pex/reactor_test.go | 70 +++--- internal/rpc/core/abci.go | 10 +- internal/rpc/core/blocks.go | 42 ++-- internal/rpc/core/blocks_test.go | 6 +- internal/rpc/core/consensus.go | 32 +-- internal/rpc/core/dev.go | 6 +- internal/rpc/core/env.go | 20 +- internal/rpc/core/events.go | 16 +- internal/rpc/core/evidence.go | 8 +- internal/rpc/core/health.go | 6 +- internal/rpc/core/mempool.go | 40 +-- internal/rpc/core/net.go | 46 ++-- internal/rpc/core/net_test.go | 6 +- internal/rpc/core/status.go | 12 +- internal/rpc/core/tx.go | 16 +- internal/state/execution.go | 12 +- internal/state/execution_test.go | 16 +- internal/state/helpers_test.go | 8 +- internal/state/indexer/block/kv/kv_test.go | 5 +- .../state/indexer/indexer_service_test.go | 8 +- internal/state/indexer/sink/kv/kv.go | 3 +- internal/state/indexer/sink/kv/kv_test.go | 17 +- internal/state/indexer/tx/kv/kv_test.go | 17 +- internal/state/state_test.go | 51 ++-- internal/state/store_test.go | 13 +- internal/state/tx_filter.go | 10 +- internal/state/validation_test.go | 20 +- internal/statesync/dispatcher.go | 4 +- internal/test/factory/genesis.go | 6 +- light/client_test.go | 1 - light/provider/http/http.go | 6 +- light/proxy/routes.go | 102 ++++---- light/rpc/client.go | 88 +++---- light/store/db/db_test.go | 1 - node/node.go | 238 +++++++++--------- node/node_test.go | 151 ++++++----- node/setup.go | 217 ++++++++-------- privval/grpc/client.go | 4 +- privval/grpc/server.go | 4 +- privval/grpc/util.go | 12 +- privval/msgs_test.go | 4 +- privval/secret_connection.go | 6 +- privval/signer_client.go | 4 +- privval/signer_requestHandler.go | 4 +- proto/tendermint/blocksync/message.go | 4 +- proto/tendermint/blocksync/message_test.go | 2 +- proto/tendermint/consensus/message.go | 4 +- proto/tendermint/mempool/message.go | 4 +- proto/tendermint/p2p/pex.go | 4 +- proto/tendermint/statesync/message.go | 4 +- proto/tendermint/statesync/message_test.go | 2 +- rpc/client/event_test.go | 4 +- rpc/client/evidence_test.go | 4 +- rpc/client/examples_test.go | 4 +- rpc/client/helpers_test.go | 10 +- rpc/client/http/http.go | 108 ++++---- rpc/client/http/ws.go | 14 +- rpc/client/interface.go | 58 ++--- rpc/client/local/local.go | 98 ++++---- rpc/client/mock/abci.go | 58 ++--- rpc/client/mock/abci_test.go | 6 +- rpc/client/mock/client.go | 46 ++-- rpc/client/mock/status.go | 8 +- rpc/client/mock/status_test.go | 8 +- rpc/client/rpc_test.go | 52 ++-- rpc/grpc/api.go | 2 +- rpc/grpc/grpc_test.go | 4 +- rpc/jsonrpc/client/decode.go | 24 +- rpc/jsonrpc/client/http_json_client.go | 18 +- rpc/jsonrpc/client/http_uri_client.go | 4 +- rpc/jsonrpc/client/ws_client.go | 30 +-- rpc/jsonrpc/client/ws_client_test.go | 6 +- rpc/jsonrpc/jsonrpc_test.go | 16 +- rpc/jsonrpc/server/http_json_handler.go | 40 +-- rpc/jsonrpc/server/http_json_handler_test.go | 50 ++-- rpc/jsonrpc/server/http_server.go | 10 +- rpc/jsonrpc/server/http_server_test.go | 12 +- rpc/jsonrpc/server/http_uri_handler.go | 32 +-- rpc/jsonrpc/server/parse_test.go | 6 +- rpc/jsonrpc/server/ws_handler.go | 40 +-- rpc/jsonrpc/server/ws_handler_test.go | 10 +- rpc/test/helpers.go | 36 +-- scripts/json2wal/main.go | 6 +- scripts/wal2json/main.go | 6 +- store/store_test.go | 20 +- types/protobuf.go | 6 +- types/protobuf_test.go | 6 +- types/validator.go | 8 +- 127 files changed, 1473 insertions(+), 1473 deletions(-) diff --git a/abci/example/kvstore/persistent_kvstore.go b/abci/example/kvstore/persistent_kvstore.go index 0fcfcadf7..40451baa9 100644 --- a/abci/example/kvstore/persistent_kvstore.go +++ b/abci/example/kvstore/persistent_kvstore.go @@ -11,9 +11,9 @@ import ( "github.com/tendermint/tendermint/abci/example/code" "github.com/tendermint/tendermint/abci/types" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/libs/log" - pc "github.com/tendermint/tendermint/proto/tendermint/crypto" + cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto" ) const ( @@ -30,7 +30,7 @@ type PersistentKVStoreApplication struct { // validator set ValUpdates []types.ValidatorUpdate - valAddrToPubKeyMap map[string]pc.PublicKey + valAddrToPubKeyMap map[string]cryptoproto.PublicKey logger log.Logger } @@ -46,7 +46,7 @@ func NewPersistentKVStoreApplication(dbDir string) *PersistentKVStoreApplication return &PersistentKVStoreApplication{ app: &Application{state: state}, - valAddrToPubKeyMap: make(map[string]pc.PublicKey), + valAddrToPubKeyMap: make(map[string]cryptoproto.PublicKey), logger: log.NewNopLogger(), } } @@ -194,8 +194,8 @@ func (app *PersistentKVStoreApplication) Validators() (validators []types.Valida return } -func MakeValSetChangeTx(pubkey pc.PublicKey, power int64) []byte { - pk, err := cryptoenc.PubKeyFromProto(pubkey) +func MakeValSetChangeTx(pubkey cryptoproto.PublicKey, power int64) []byte { + pk, err := encoding.PubKeyFromProto(pubkey) if err != nil { panic(err) } @@ -243,7 +243,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon // add, update, or remove a validator func (app *PersistentKVStoreApplication) updateValidator(v types.ValidatorUpdate) types.ResponseDeliverTx { - pubkey, err := cryptoenc.PubKeyFromProto(v.PubKey) + pubkey, err := encoding.PubKeyFromProto(v.PubKey) if err != nil { panic(fmt.Errorf("can't decode public key: %w", err)) } diff --git a/abci/types/pubkey.go b/abci/types/pubkey.go index a0f746992..c188fc8f5 100644 --- a/abci/types/pubkey.go +++ b/abci/types/pubkey.go @@ -4,7 +4,7 @@ import ( fmt "fmt" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/crypto/secp256k1" "github.com/tendermint/tendermint/crypto/sr25519" ) @@ -12,7 +12,7 @@ import ( func Ed25519ValidatorUpdate(pk []byte, power int64) ValidatorUpdate { pke := ed25519.PubKey(pk) - pkp, err := cryptoenc.PubKeyToProto(pke) + pkp, err := encoding.PubKeyToProto(pke) if err != nil { panic(err) } @@ -29,7 +29,7 @@ func UpdateValidator(pk []byte, power int64, keyType string) ValidatorUpdate { return Ed25519ValidatorUpdate(pk, power) case secp256k1.KeyType: pke := secp256k1.PubKey(pk) - pkp, err := cryptoenc.PubKeyToProto(pke) + pkp, err := encoding.PubKeyToProto(pke) if err != nil { panic(err) } @@ -39,7 +39,7 @@ func UpdateValidator(pk []byte, power int64, keyType string) ValidatorUpdate { } case sr25519.KeyType: pke := sr25519.PubKey(pk) - pkp, err := cryptoenc.PubKeyToProto(pke) + pkp, err := encoding.PubKeyToProto(pke) if err != nil { panic(err) } diff --git a/cmd/tendermint/commands/debug/dump.go b/cmd/tendermint/commands/debug/dump.go index f99975a75..cb1cc942a 100644 --- a/cmd/tendermint/commands/debug/dump.go +++ b/cmd/tendermint/commands/debug/dump.go @@ -11,7 +11,7 @@ import ( "github.com/spf13/cobra" "github.com/spf13/viper" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/libs/cli" rpchttp "github.com/tendermint/tendermint/rpc/client/http" ) @@ -65,9 +65,9 @@ func dumpCmdHandler(_ *cobra.Command, args []string) error { } home := viper.GetString(cli.HomeFlag) - conf := cfg.DefaultConfig() + conf := config.DefaultConfig() conf = conf.SetRoot(home) - cfg.EnsureRoot(conf.RootDir) + config.EnsureRoot(conf.RootDir) dumpDebugData(outDir, conf, rpc) @@ -79,7 +79,7 @@ func dumpCmdHandler(_ *cobra.Command, args []string) error { return nil } -func dumpDebugData(outDir string, conf *cfg.Config, rpc *rpchttp.HTTP) { +func dumpDebugData(outDir string, conf *config.Config, rpc *rpchttp.HTTP) { start := time.Now().UTC() tmpDir, err := ioutil.TempDir(outDir, "tendermint_debug_tmp") diff --git a/cmd/tendermint/commands/debug/kill.go b/cmd/tendermint/commands/debug/kill.go index bef534152..3e749e513 100644 --- a/cmd/tendermint/commands/debug/kill.go +++ b/cmd/tendermint/commands/debug/kill.go @@ -14,7 +14,7 @@ import ( "github.com/spf13/cobra" "github.com/spf13/viper" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/libs/cli" rpchttp "github.com/tendermint/tendermint/rpc/client/http" ) @@ -50,9 +50,9 @@ func killCmdHandler(cmd *cobra.Command, args []string) error { } home := viper.GetString(cli.HomeFlag) - conf := cfg.DefaultConfig() + conf := config.DefaultConfig() conf = conf.SetRoot(home) - cfg.EnsureRoot(conf.RootDir) + config.EnsureRoot(conf.RootDir) // Create a temporary directory which will contain all the state dumps and // relevant files and directories that will be compressed into a file. diff --git a/cmd/tendermint/commands/debug/util.go b/cmd/tendermint/commands/debug/util.go index 226bfadc7..fa356c488 100644 --- a/cmd/tendermint/commands/debug/util.go +++ b/cmd/tendermint/commands/debug/util.go @@ -9,7 +9,7 @@ import ( "path" "path/filepath" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" rpchttp "github.com/tendermint/tendermint/rpc/client/http" ) @@ -48,7 +48,7 @@ func dumpConsensusState(rpc *rpchttp.HTTP, dir, filename string) error { // copyWAL copies the Tendermint node's WAL file. It returns an error if the // WAL file cannot be read or copied. -func copyWAL(conf *cfg.Config, dir string) error { +func copyWAL(conf *config.Config, dir string) error { walPath := conf.Consensus.WalFile() walFile := filepath.Base(walPath) diff --git a/cmd/tendermint/commands/light.go b/cmd/tendermint/commands/light.go index 5e7446e51..f4c9a21da 100644 --- a/cmd/tendermint/commands/light.go +++ b/cmd/tendermint/commands/light.go @@ -11,7 +11,6 @@ import ( "time" "github.com/spf13/cobra" - dbm "github.com/tendermint/tm-db" "github.com/tendermint/tendermint/libs/log" diff --git a/cmd/tendermint/commands/reindex_event.go b/cmd/tendermint/commands/reindex_event.go index b5e98a29a..ca176df11 100644 --- a/cmd/tendermint/commands/reindex_event.go +++ b/cmd/tendermint/commands/reindex_event.go @@ -6,7 +6,7 @@ import ( "strings" "github.com/spf13/cobra" - tmdb "github.com/tendermint/tm-db" + dbm "github.com/tendermint/tm-db" abcitypes "github.com/tendermint/tendermint/abci/types" tmcfg "github.com/tendermint/tendermint/config" @@ -15,7 +15,7 @@ import ( "github.com/tendermint/tendermint/internal/state/indexer" "github.com/tendermint/tendermint/internal/state/indexer/sink/kv" "github.com/tendermint/tendermint/internal/state/indexer/sink/psql" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" ) @@ -129,17 +129,17 @@ func loadEventSinks(cfg *tmcfg.Config) ([]indexer.EventSink, error) { } func loadStateAndBlockStore(cfg *tmcfg.Config) (*store.BlockStore, state.Store, error) { - dbType := tmdb.BackendType(cfg.DBBackend) + dbType := dbm.BackendType(cfg.DBBackend) // Get BlockStore - blockStoreDB, err := tmdb.NewDB("blockstore", dbType, cfg.DBDir()) + blockStoreDB, err := dbm.NewDB("blockstore", dbType, cfg.DBDir()) if err != nil { return nil, nil, err } blockStore := store.NewBlockStore(blockStoreDB) // Get StateStore - stateDB, err := tmdb.NewDB("state", dbType, cfg.DBDir()) + stateDB, err := dbm.NewDB("state", dbType, cfg.DBDir()) if err != nil { return nil, nil, err } @@ -221,14 +221,15 @@ func checkValidHeight(bs state.BlockStore) error { } if startHeight < base { - return fmt.Errorf("%s (requested start height: %d, base height: %d)", ctypes.ErrHeightNotAvailable, startHeight, base) + return fmt.Errorf("%s (requested start height: %d, base height: %d)", + coretypes.ErrHeightNotAvailable, startHeight, base) } height := bs.Height() if startHeight > height { return fmt.Errorf( - "%s (requested start height: %d, store height: %d)", ctypes.ErrHeightNotAvailable, startHeight, height) + "%s (requested start height: %d, store height: %d)", coretypes.ErrHeightNotAvailable, startHeight, height) } if endHeight == 0 || endHeight > height { @@ -238,13 +239,13 @@ func checkValidHeight(bs state.BlockStore) error { if endHeight < base { return fmt.Errorf( - "%s (requested end height: %d, base height: %d)", ctypes.ErrHeightNotAvailable, endHeight, base) + "%s (requested end height: %d, base height: %d)", coretypes.ErrHeightNotAvailable, endHeight, base) } if endHeight < startHeight { return fmt.Errorf( "%s (requested the end height: %d is less than the start height: %d)", - ctypes.ErrInvalidRequest, startHeight, endHeight) + coretypes.ErrInvalidRequest, startHeight, endHeight) } return nil diff --git a/cmd/tendermint/main.go b/cmd/tendermint/main.go index c006c297d..9f908a1ed 100644 --- a/cmd/tendermint/main.go +++ b/cmd/tendermint/main.go @@ -6,9 +6,9 @@ import ( cmd "github.com/tendermint/tendermint/cmd/tendermint/commands" "github.com/tendermint/tendermint/cmd/tendermint/commands/debug" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/libs/cli" - nm "github.com/tendermint/tendermint/node" + "github.com/tendermint/tendermint/node" ) func main() { @@ -42,12 +42,12 @@ func main() { // * Provide their own DB implementation // can copy this file and use something other than the // node.NewDefault function - nodeFunc := nm.NewDefault + nodeFunc := node.NewDefault // Create & start node rootCmd.AddCommand(cmd.NewRunNodeCmd(nodeFunc)) - cmd := cli.PrepareBaseCmd(rootCmd, "TM", os.ExpandEnv(filepath.Join("$HOME", cfg.DefaultTendermintDir))) + cmd := cli.PrepareBaseCmd(rootCmd, "TM", os.ExpandEnv(filepath.Join("$HOME", config.DefaultTendermintDir))) if err := cmd.Execute(); err != nil { panic(err) } diff --git a/config/db.go b/config/db.go index 3ae274a50..8f489a87a 100644 --- a/config/db.go +++ b/config/db.go @@ -1,9 +1,10 @@ package config import ( + dbm "github.com/tendermint/tm-db" + "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/service" - db "github.com/tendermint/tm-db" ) // ServiceProvider takes a config and a logger and returns a ready to go Node. @@ -16,11 +17,11 @@ type DBContext struct { } // DBProvider takes a DBContext and returns an instantiated DB. -type DBProvider func(*DBContext) (db.DB, error) +type DBProvider func(*DBContext) (dbm.DB, error) // DefaultDBProvider returns a database using the DBBackend and DBDir // specified in the Config. -func DefaultDBProvider(ctx *DBContext) (db.DB, error) { - dbType := db.BackendType(ctx.Config.DBBackend) - return db.NewDB(ctx.ID, dbType, ctx.Config.DBDir()) +func DefaultDBProvider(ctx *DBContext) (dbm.DB, error) { + dbType := dbm.BackendType(ctx.Config.DBBackend) + return dbm.NewDB(ctx.ID, dbType, ctx.Config.DBDir()) } diff --git a/crypto/encoding/codec.go b/crypto/encoding/codec.go index 64e4e7c6f..37249bcb3 100644 --- a/crypto/encoding/codec.go +++ b/crypto/encoding/codec.go @@ -8,34 +8,34 @@ import ( "github.com/tendermint/tendermint/crypto/secp256k1" "github.com/tendermint/tendermint/crypto/sr25519" "github.com/tendermint/tendermint/libs/json" - pc "github.com/tendermint/tendermint/proto/tendermint/crypto" + cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto" ) func init() { - json.RegisterType((*pc.PublicKey)(nil), "tendermint.crypto.PublicKey") - json.RegisterType((*pc.PublicKey_Ed25519)(nil), "tendermint.crypto.PublicKey_Ed25519") - json.RegisterType((*pc.PublicKey_Secp256K1)(nil), "tendermint.crypto.PublicKey_Secp256K1") + json.RegisterType((*cryptoproto.PublicKey)(nil), "tendermint.crypto.PublicKey") + json.RegisterType((*cryptoproto.PublicKey_Ed25519)(nil), "tendermint.crypto.PublicKey_Ed25519") + json.RegisterType((*cryptoproto.PublicKey_Secp256K1)(nil), "tendermint.crypto.PublicKey_Secp256K1") } // PubKeyToProto takes crypto.PubKey and transforms it to a protobuf Pubkey -func PubKeyToProto(k crypto.PubKey) (pc.PublicKey, error) { - var kp pc.PublicKey +func PubKeyToProto(k crypto.PubKey) (cryptoproto.PublicKey, error) { + var kp cryptoproto.PublicKey switch k := k.(type) { case ed25519.PubKey: - kp = pc.PublicKey{ - Sum: &pc.PublicKey_Ed25519{ + kp = cryptoproto.PublicKey{ + Sum: &cryptoproto.PublicKey_Ed25519{ Ed25519: k, }, } case secp256k1.PubKey: - kp = pc.PublicKey{ - Sum: &pc.PublicKey_Secp256K1{ + kp = cryptoproto.PublicKey{ + Sum: &cryptoproto.PublicKey_Secp256K1{ Secp256K1: k, }, } case sr25519.PubKey: - kp = pc.PublicKey{ - Sum: &pc.PublicKey_Sr25519{ + kp = cryptoproto.PublicKey{ + Sum: &cryptoproto.PublicKey_Sr25519{ Sr25519: k, }, } @@ -46,9 +46,9 @@ func PubKeyToProto(k crypto.PubKey) (pc.PublicKey, error) { } // PubKeyFromProto takes a protobuf Pubkey and transforms it to a crypto.Pubkey -func PubKeyFromProto(k pc.PublicKey) (crypto.PubKey, error) { +func PubKeyFromProto(k cryptoproto.PublicKey) (crypto.PubKey, error) { switch k := k.Sum.(type) { - case *pc.PublicKey_Ed25519: + case *cryptoproto.PublicKey_Ed25519: if len(k.Ed25519) != ed25519.PubKeySize { return nil, fmt.Errorf("invalid size for PubKeyEd25519. Got %d, expected %d", len(k.Ed25519), ed25519.PubKeySize) @@ -56,7 +56,7 @@ func PubKeyFromProto(k pc.PublicKey) (crypto.PubKey, error) { pk := make(ed25519.PubKey, ed25519.PubKeySize) copy(pk, k.Ed25519) return pk, nil - case *pc.PublicKey_Secp256K1: + case *cryptoproto.PublicKey_Secp256K1: if len(k.Secp256K1) != secp256k1.PubKeySize { return nil, fmt.Errorf("invalid size for PubKeySecp256k1. Got %d, expected %d", len(k.Secp256K1), secp256k1.PubKeySize) @@ -64,7 +64,7 @@ func PubKeyFromProto(k pc.PublicKey) (crypto.PubKey, error) { pk := make(secp256k1.PubKey, secp256k1.PubKeySize) copy(pk, k.Secp256K1) return pk, nil - case *pc.PublicKey_Sr25519: + case *cryptoproto.PublicKey_Sr25519: if len(k.Sr25519) != sr25519.PubKeySize { return nil, fmt.Errorf("invalid size for PubKeySr25519. Got %d, expected %d", len(k.Sr25519), sr25519.PubKeySize) diff --git a/crypto/secp256k1/secp256k1_test.go b/crypto/secp256k1/secp256k1_test.go index f8bf29971..7a1109293 100644 --- a/crypto/secp256k1/secp256k1_test.go +++ b/crypto/secp256k1/secp256k1_test.go @@ -5,14 +5,13 @@ import ( "math/big" "testing" + underlyingSecp256k1 "github.com/btcsuite/btcd/btcec" "github.com/btcsuite/btcutil/base58" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/secp256k1" - - underlyingSecp256k1 "github.com/btcsuite/btcd/btcec" ) type keyData struct { diff --git a/crypto/xchacha20poly1305/xchachapoly_test.go b/crypto/xchacha20poly1305/xchachapoly_test.go index b17b1c376..75953d72d 100644 --- a/crypto/xchacha20poly1305/xchachapoly_test.go +++ b/crypto/xchacha20poly1305/xchachapoly_test.go @@ -2,8 +2,8 @@ package xchacha20poly1305 import ( "bytes" - cr "crypto/rand" - mr "math/rand" + crand "crypto/rand" + mrand "math/rand" "testing" ) @@ -19,23 +19,23 @@ func TestRandom(t *testing.T) { var nonce [24]byte var key [32]byte - al := mr.Intn(128) - pl := mr.Intn(16384) + al := mrand.Intn(128) + pl := mrand.Intn(16384) ad := make([]byte, al) plaintext := make([]byte, pl) - _, err := cr.Read(key[:]) + _, err := crand.Read(key[:]) if err != nil { t.Errorf("error on read: %w", err) } - _, err = cr.Read(nonce[:]) + _, err = crand.Read(nonce[:]) if err != nil { t.Errorf("error on read: %w", err) } - _, err = cr.Read(ad) + _, err = crand.Read(ad) if err != nil { t.Errorf("error on read: %w", err) } - _, err = cr.Read(plaintext) + _, err = crand.Read(plaintext) if err != nil { t.Errorf("error on read: %w", err) } @@ -59,7 +59,7 @@ func TestRandom(t *testing.T) { } if len(ad) > 0 { - alterAdIdx := mr.Intn(len(ad)) + alterAdIdx := mrand.Intn(len(ad)) ad[alterAdIdx] ^= 0x80 if _, err := aead.Open(nil, nonce[:], ct, ad); err == nil { t.Errorf("random #%d: Open was successful after altering additional data", i) @@ -67,14 +67,14 @@ func TestRandom(t *testing.T) { ad[alterAdIdx] ^= 0x80 } - alterNonceIdx := mr.Intn(aead.NonceSize()) + alterNonceIdx := mrand.Intn(aead.NonceSize()) nonce[alterNonceIdx] ^= 0x80 if _, err := aead.Open(nil, nonce[:], ct, ad); err == nil { t.Errorf("random #%d: Open was successful after altering nonce", i) } nonce[alterNonceIdx] ^= 0x80 - alterCtIdx := mr.Intn(len(ct)) + alterCtIdx := mrand.Intn(len(ct)) ct[alterCtIdx] ^= 0x80 if _, err := aead.Open(nil, nonce[:], ct, ad); err == nil { t.Errorf("random #%d: Open was successful after altering ciphertext", i) diff --git a/internal/blocksync/v0/reactor.go b/internal/blocksync/v0/reactor.go index 645b39b4c..4c378d040 100644 --- a/internal/blocksync/v0/reactor.go +++ b/internal/blocksync/v0/reactor.go @@ -6,13 +6,13 @@ import ( "sync" "time" - bc "github.com/tendermint/tendermint/internal/blocksync" - cons "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/blocksync" + "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/p2p" sm "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/libs/service" - tmSync "github.com/tendermint/tendermint/libs/sync" + tmsync "github.com/tendermint/tendermint/libs/sync" bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" @@ -36,7 +36,7 @@ var ( Priority: 5, SendQueueCapacity: 1000, RecvBufferCapacity: 1024, - RecvMessageCapacity: bc.MaxMsgSize, + RecvMessageCapacity: blocksync.MaxMsgSize, MaxSendBytes: 100, }, }, @@ -85,7 +85,7 @@ type Reactor struct { store *store.BlockStore pool *BlockPool consReactor consensusReactor - blockSync *tmSync.AtomicBool + blockSync *tmsync.AtomicBool blockSyncCh *p2p.Channel // blockSyncOutBridgeCh defines a channel that acts as a bridge between sending Envelope @@ -107,7 +107,7 @@ type Reactor struct { // stopping the p2p Channel(s). poolWG sync.WaitGroup - metrics *cons.Metrics + metrics *consensus.Metrics syncStartTime time.Time } @@ -122,7 +122,7 @@ func NewReactor( blockSyncCh *p2p.Channel, peerUpdates *p2p.PeerUpdates, blockSync bool, - metrics *cons.Metrics, + metrics *consensus.Metrics, ) (*Reactor, error) { if state.LastBlockHeight != store.Height() { return nil, fmt.Errorf("state (%v) and store (%v) height mismatch", state.LastBlockHeight, store.Height()) @@ -142,7 +142,7 @@ func NewReactor( store: store, pool: NewBlockPool(startHeight, requestsCh, errorsCh), consReactor: consReactor, - blockSync: tmSync.NewBool(blockSync), + blockSync: tmsync.NewBool(blockSync), requestsCh: requestsCh, errorsCh: errorsCh, blockSyncCh: blockSyncCh, diff --git a/internal/blocksync/v0/reactor_test.go b/internal/blocksync/v0/reactor_test.go index 9a79c8cf3..14e0fbf1d 100644 --- a/internal/blocksync/v0/reactor_test.go +++ b/internal/blocksync/v0/reactor_test.go @@ -6,11 +6,12 @@ import ( "time" "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" - cons "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/config" + "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" @@ -22,7 +23,6 @@ import ( bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" - dbm "github.com/tendermint/tm-db" ) type reactorTestSuite struct { @@ -165,7 +165,7 @@ func (rts *reactorTestSuite) addNode(t *testing.T, rts.blockSyncChannels[nodeID], rts.peerUpdates[nodeID], rts.blockSync, - cons.NopMetrics()) + consensus.NopMetrics()) require.NoError(t, err) require.NoError(t, rts.reactors[nodeID].Start()) @@ -182,10 +182,10 @@ func (rts *reactorTestSuite) start(t *testing.T) { } func TestReactor_AbruptDisconnect(t *testing.T) { - config := cfg.ResetTestRoot("block_sync_reactor_test") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("block_sync_reactor_test") + defer os.RemoveAll(cfg.RootDir) - genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30) + genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30) maxBlockHeight := int64(64) rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0) @@ -217,10 +217,10 @@ func TestReactor_AbruptDisconnect(t *testing.T) { } func TestReactor_SyncTime(t *testing.T) { - config := cfg.ResetTestRoot("block_sync_reactor_test") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("block_sync_reactor_test") + defer os.RemoveAll(cfg.RootDir) - genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30) + genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30) maxBlockHeight := int64(101) rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0) @@ -240,10 +240,10 @@ func TestReactor_SyncTime(t *testing.T) { } func TestReactor_NoBlockResponse(t *testing.T) { - config := cfg.ResetTestRoot("block_sync_reactor_test") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("block_sync_reactor_test") + defer os.RemoveAll(cfg.RootDir) - genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30) + genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30) maxBlockHeight := int64(65) rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0}, 0) @@ -287,11 +287,11 @@ func TestReactor_BadBlockStopsPeer(t *testing.T) { // See: https://github.com/tendermint/tendermint/issues/6005 t.SkipNow() - config := cfg.ResetTestRoot("block_sync_reactor_test") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("block_sync_reactor_test") + defer os.RemoveAll(cfg.RootDir) maxBlockHeight := int64(48) - genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30) + genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30) rts := setup(t, genDoc, privVals[0], []int64{maxBlockHeight, 0, 0, 0, 0}, 1000) @@ -325,7 +325,7 @@ func TestReactor_BadBlockStopsPeer(t *testing.T) { // // XXX: This causes a potential race condition. // See: https://github.com/tendermint/tendermint/issues/6005 - otherGenDoc, otherPrivVals := factory.RandGenesisDoc(config, 1, false, 30) + otherGenDoc, otherPrivVals := factory.RandGenesisDoc(cfg, 1, false, 30) newNode := rts.network.MakeNode(t, p2ptest.NodeOptions{ MaxPeers: uint16(len(rts.nodes) + 1), MaxConnected: uint16(len(rts.nodes) + 1), diff --git a/internal/blocksync/v2/processor.go b/internal/blocksync/v2/processor.go index 12959d5b1..d1850eb1c 100644 --- a/internal/blocksync/v2/processor.go +++ b/internal/blocksync/v2/processor.go @@ -3,7 +3,7 @@ package v2 import ( "fmt" - tmState "github.com/tendermint/tendermint/internal/state" + tmstate "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/types" ) @@ -36,7 +36,7 @@ func (e pcBlockProcessed) String() string { type pcFinished struct { priorityNormal blocksSynced int - tmState tmState.State + tmState tmstate.State } func (p pcFinished) Error() string { @@ -148,11 +148,11 @@ func (state *pcState) handle(event Event) (Event, error) { return noOp, nil case rProcessBlock: - tmState := state.context.tmState() + tmstate := state.context.tmState() firstItem, secondItem, err := state.nextTwo() if err != nil { if state.draining { - return pcFinished{tmState: tmState, blocksSynced: state.blocksSynced}, nil + return pcFinished{tmState: tmstate, blocksSynced: state.blocksSynced}, nil } return noOp, nil } @@ -164,7 +164,7 @@ func (state *pcState) handle(event Event) (Event, error) { ) // verify if +second+ last commit "confirms" +first+ block - err = state.context.verifyCommit(tmState.ChainID, firstID, first.Height, second.LastCommit) + err = state.context.verifyCommit(tmstate.ChainID, firstID, first.Height, second.LastCommit) if err != nil { state.purgePeer(firstItem.peerID) if firstItem.peerID != secondItem.peerID { diff --git a/internal/blocksync/v2/processor_context.go b/internal/blocksync/v2/processor_context.go index caf25e09c..86b380f98 100644 --- a/internal/blocksync/v2/processor_context.go +++ b/internal/blocksync/v2/processor_context.go @@ -3,7 +3,7 @@ package v2 import ( "fmt" - cons "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/types" ) @@ -21,10 +21,10 @@ type pContext struct { store blockStore applier blockApplier state state.State - metrics *cons.Metrics + metrics *consensus.Metrics } -func newProcessorContext(st blockStore, ex blockApplier, s state.State, m *cons.Metrics) *pContext { +func newProcessorContext(st blockStore, ex blockApplier, s state.State, m *consensus.Metrics) *pContext { return &pContext{ store: st, applier: ex, diff --git a/internal/blocksync/v2/processor_test.go b/internal/blocksync/v2/processor_test.go index c9b8c62e1..7c12b3610 100644 --- a/internal/blocksync/v2/processor_test.go +++ b/internal/blocksync/v2/processor_test.go @@ -5,7 +5,7 @@ import ( "github.com/stretchr/testify/assert" - tmState "github.com/tendermint/tendermint/internal/state" + tmstate "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/types" ) @@ -33,7 +33,7 @@ func makePcBlock(height int64) *types.Block { // makeState takes test parameters and creates a specific processor state. func makeState(p *params) *pcState { var ( - tmState = tmState.State{LastBlockHeight: p.height} + tmState = tmstate.State{LastBlockHeight: p.height} context = newMockProcessorContext(tmState, p.verBL, p.appBL) ) state := newPcState(context) @@ -207,7 +207,7 @@ func TestRProcessBlockSuccess(t *testing.T) { { // finish when H+1 or/and H+2 are missing event: rProcessBlock{}, wantState: ¶ms{height: 1, items: []pcBlock{{"P2", 2}, {"P1", 4}}, blocksSynced: 1, draining: true}, - wantNextEvent: pcFinished{tmState: tmState.State{LastBlockHeight: 1}, blocksSynced: 1}, + wantNextEvent: pcFinished{tmState: tmstate.State{LastBlockHeight: 1}, blocksSynced: 1}, }, }, }, @@ -271,7 +271,7 @@ func TestScFinishedEv(t *testing.T) { { currentState: ¶ms{height: 100, items: []pcBlock{}, blocksSynced: 100}, event: scFinishedEv{}, wantState: ¶ms{height: 100, items: []pcBlock{}, blocksSynced: 100}, - wantNextEvent: pcFinished{tmState: tmState.State{LastBlockHeight: 100}, blocksSynced: 100}, + wantNextEvent: pcFinished{tmState: tmstate.State{LastBlockHeight: 100}, blocksSynced: 100}, }, }, }, @@ -282,7 +282,7 @@ func TestScFinishedEv(t *testing.T) { currentState: ¶ms{height: 100, items: []pcBlock{ {"P1", 101}}, blocksSynced: 100}, event: scFinishedEv{}, wantState: ¶ms{height: 100, items: []pcBlock{{"P1", 101}}, blocksSynced: 100}, - wantNextEvent: pcFinished{tmState: tmState.State{LastBlockHeight: 100}, blocksSynced: 100}, + wantNextEvent: pcFinished{tmState: tmstate.State{LastBlockHeight: 100}, blocksSynced: 100}, }, }, }, diff --git a/internal/blocksync/v2/reactor.go b/internal/blocksync/v2/reactor.go index bd2b85038..f8dcbcf64 100644 --- a/internal/blocksync/v2/reactor.go +++ b/internal/blocksync/v2/reactor.go @@ -5,11 +5,11 @@ import ( "fmt" "time" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" - bc "github.com/tendermint/tendermint/internal/blocksync" + "github.com/tendermint/tendermint/internal/blocksync" "github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior" - cons "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/consensus" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/internal/state" @@ -61,7 +61,7 @@ type blockApplier interface { // XXX: unify naming in this package around tmState func newReactor(state state.State, store blockStore, reporter behavior.Reporter, - blockApplier blockApplier, blockSync bool, metrics *cons.Metrics) *BlockchainReactor { + blockApplier blockApplier, blockSync bool, metrics *consensus.Metrics) *BlockchainReactor { initHeight := state.LastBlockHeight + 1 if initHeight == 1 { initHeight = state.InitialHeight @@ -91,7 +91,7 @@ func NewBlockchainReactor( blockApplier blockApplier, store blockStore, blockSync bool, - metrics *cons.Metrics) *BlockchainReactor { + metrics *consensus.Metrics) *BlockchainReactor { reporter := behavior.NewMockReporter() return newReactor(state, store, reporter, blockApplier, blockSync, metrics) } @@ -605,7 +605,7 @@ func (r *BlockchainReactor) GetChannels() []*p2p.ChannelDescriptor { Priority: 5, SendQueueCapacity: 2000, RecvBufferCapacity: 1024, - RecvMessageCapacity: bc.MaxMsgSize, + RecvMessageCapacity: blocksync.MaxMsgSize, }, } } diff --git a/internal/blocksync/v2/reactor_test.go b/internal/blocksync/v2/reactor_test.go index ca8ba41a0..8cb675a0a 100644 --- a/internal/blocksync/v2/reactor_test.go +++ b/internal/blocksync/v2/reactor_test.go @@ -15,9 +15,9 @@ import ( abciclient "github.com/tendermint/tendermint/abci/client" abci "github.com/tendermint/tendermint/abci/types" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/internal/blocksync/v2/internal/behavior" - cons "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/mempool/mock" "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/internal/p2p/conn" @@ -177,7 +177,7 @@ func newTestReactor(t *testing.T, p testReactorParams) *BlockchainReactor { require.NoError(t, err) } - r := newReactor(state, store, reporter, appl, true, cons.NopMetrics()) + r := newReactor(state, store, reporter, appl, true, consensus.NopMetrics()) logger := log.TestingLogger() r.SetLogger(logger.With("module", "blockchain")) @@ -365,9 +365,9 @@ func TestReactorHelperMode(t *testing.T) { channelID = byte(0x40) ) - config := cfg.ResetTestRoot("blockchain_reactor_v2_test") - defer os.RemoveAll(config.RootDir) - genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30) + cfg := config.ResetTestRoot("blockchain_reactor_v2_test") + defer os.RemoveAll(cfg.RootDir) + genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30) params := testReactorParams{ logger: log.TestingLogger(), @@ -455,9 +455,9 @@ func TestReactorHelperMode(t *testing.T) { } func TestReactorSetSwitchNil(t *testing.T) { - config := cfg.ResetTestRoot("blockchain_reactor_v2_test") - defer os.RemoveAll(config.RootDir) - genDoc, privVals := factory.RandGenesisDoc(config, 1, false, 30) + cfg := config.ResetTestRoot("blockchain_reactor_v2_test") + defer os.RemoveAll(cfg.RootDir) + genDoc, privVals := factory.RandGenesisDoc(cfg, 1, false, 30) reactor := newTestReactor(t, testReactorParams{ logger: log.TestingLogger(), diff --git a/internal/consensus/byzantine_test.go b/internal/consensus/byzantine_test.go index a202a4738..bff9f4ace 100644 --- a/internal/consensus/byzantine_test.go +++ b/internal/consensus/byzantine_test.go @@ -10,6 +10,8 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + dbm "github.com/tendermint/tm-db" + abciclient "github.com/tendermint/tendermint/abci/client" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/internal/evidence" @@ -23,7 +25,6 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" - dbm "github.com/tendermint/tm-db" ) // Byzantine node sends two different prevotes (nil and blockID) to the same diff --git a/internal/consensus/common_test.go b/internal/consensus/common_test.go index b7fdd984e..2bd926c45 100644 --- a/internal/consensus/common_test.go +++ b/internal/consensus/common_test.go @@ -7,21 +7,19 @@ import ( "io" "io/ioutil" "os" + "path" "path/filepath" "sync" "testing" "time" "github.com/stretchr/testify/require" - - "path" - 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/config" cstypes "github.com/tendermint/tendermint/internal/consensus/types" tmsync "github.com/tendermint/tendermint/internal/libs/sync" mempoolv0 "github.com/tendermint/tendermint/internal/mempool/v0" @@ -49,10 +47,10 @@ const ( // test. type cleanupFunc func() -func configSetup(t *testing.T) *cfg.Config { +func configSetup(t *testing.T) *config.Config { t.Helper() - config := ResetConfig("consensus_reactor_test") + cfg := ResetConfig("consensus_reactor_test") consensusReplayConfig := ResetConfig("consensus_replay_test") configStateTest := ResetConfig("consensus_state_test") @@ -60,13 +58,13 @@ func configSetup(t *testing.T) *cfg.Config { configByzantineTest := ResetConfig("consensus_byzantine_test") t.Cleanup(func() { - os.RemoveAll(config.RootDir) + os.RemoveAll(cfg.RootDir) os.RemoveAll(consensusReplayConfig.RootDir) os.RemoveAll(configStateTest.RootDir) os.RemoveAll(configMempoolTest.RootDir) os.RemoveAll(configByzantineTest.RootDir) }) - return config + return cfg } func ensureDir(dir string, mode os.FileMode) { @@ -75,8 +73,8 @@ func ensureDir(dir string, mode os.FileMode) { } } -func ResetConfig(name string) *cfg.Config { - return cfg.ResetTestRoot(name) +func ResetConfig(name string) *config.Config { + return config.ResetTestRoot(name) } //------------------------------------------------------------------------------- @@ -102,7 +100,7 @@ func newValidatorStub(privValidator types.PrivValidator, valIndex int32) *valida } func (vs *validatorStub) signVote( - config *cfg.Config, + cfg *config.Config, voteType tmproto.SignedMsgType, hash []byte, header types.PartSetHeader) (*types.Vote, error) { @@ -122,7 +120,7 @@ func (vs *validatorStub) signVote( BlockID: types.BlockID{Hash: hash, PartSetHeader: header}, } v := vote.ToProto() - if err := vs.PrivValidator.SignVote(context.Background(), config.ChainID(), v); err != nil { + if err := vs.PrivValidator.SignVote(context.Background(), cfg.ChainID(), v); err != nil { return nil, fmt.Errorf("sign vote failed: %w", err) } @@ -141,12 +139,12 @@ func (vs *validatorStub) signVote( // Sign vote for type/hash/header func signVote( vs *validatorStub, - config *cfg.Config, + cfg *config.Config, voteType tmproto.SignedMsgType, hash []byte, header types.PartSetHeader) *types.Vote { - v, err := vs.signVote(config, voteType, hash, header) + v, err := vs.signVote(cfg, voteType, hash, header) if err != nil { panic(fmt.Errorf("failed to sign vote: %v", err)) } @@ -157,14 +155,14 @@ func signVote( } func signVotes( - config *cfg.Config, + cfg *config.Config, voteType tmproto.SignedMsgType, hash []byte, header types.PartSetHeader, vss ...*validatorStub) []*types.Vote { votes := make([]*types.Vote, len(vss)) for i, vs := range vss { - votes[i] = signVote(vs, config, voteType, hash, header) + votes[i] = signVote(vs, cfg, voteType, hash, header) } return votes } @@ -255,14 +253,14 @@ func addVotes(to *State, votes ...*types.Vote) { } func signAddVotes( - config *cfg.Config, + cfg *config.Config, to *State, voteType tmproto.SignedMsgType, hash []byte, header types.PartSetHeader, vss ...*validatorStub, ) { - votes := signVotes(config, voteType, hash, header, vss...) + votes := signVotes(cfg, voteType, hash, header, vss...) addVotes(to, votes...) } @@ -387,12 +385,12 @@ func subscribeToVoter(cs *State, addr []byte) <-chan tmpubsub.Message { // consensus states func newState(state sm.State, pv types.PrivValidator, app abci.Application) *State { - config := cfg.ResetTestRoot("consensus_state_test") - return newStateWithConfig(config, state, pv, app) + cfg := config.ResetTestRoot("consensus_state_test") + return newStateWithConfig(cfg, state, pv, app) } func newStateWithConfig( - thisConfig *cfg.Config, + thisConfig *config.Config, state sm.State, pv types.PrivValidator, app abci.Application, @@ -402,7 +400,7 @@ func newStateWithConfig( } func newStateWithConfigAndBlockStore( - thisConfig *cfg.Config, + thisConfig *config.Config, state sm.State, pv types.PrivValidator, app abci.Application, @@ -444,10 +442,10 @@ func newStateWithConfigAndBlockStore( return cs } -func loadPrivValidator(config *cfg.Config) *privval.FilePV { - privValidatorKeyFile := config.PrivValidator.KeyFile() +func loadPrivValidator(cfg *config.Config) *privval.FilePV { + privValidatorKeyFile := cfg.PrivValidator.KeyFile() ensureDir(filepath.Dir(privValidatorKeyFile), 0700) - privValidatorStateFile := config.PrivValidator.StateFile() + privValidatorStateFile := cfg.PrivValidator.StateFile() privValidator, err := privval.LoadOrGenFilePV(privValidatorKeyFile, privValidatorStateFile) if err != nil { panic(err) @@ -456,9 +454,9 @@ func loadPrivValidator(config *cfg.Config) *privval.FilePV { return privValidator } -func randState(config *cfg.Config, nValidators int) (*State, []*validatorStub) { +func randState(cfg *config.Config, nValidators int) (*State, []*validatorStub) { // Get State - state, privVals := randGenesisState(config, nValidators, false, 10) + state, privVals := randGenesisState(cfg, nValidators, false, 10) vss := make([]*validatorStub, nValidators) @@ -704,15 +702,15 @@ func consensusLogger() log.Logger { func randConsensusState( t *testing.T, - config *cfg.Config, + cfg *config.Config, nValidators int, testName string, tickerFunc func() TimeoutTicker, appFunc func() abci.Application, - configOpts ...func(*cfg.Config), + configOpts ...func(*config.Config), ) ([]*State, cleanupFunc) { - genDoc, privVals := factory.RandGenesisDoc(config, nValidators, false, 30) + genDoc, privVals := factory.RandGenesisDoc(cfg, nValidators, false, 30) css := make([]*State, nValidators) logger := consensusLogger() @@ -759,18 +757,18 @@ func randConsensusState( // nPeers = nValidators + nNotValidator func randConsensusNetWithPeers( - config *cfg.Config, + cfg *config.Config, nValidators, nPeers int, testName string, tickerFunc func() TimeoutTicker, appFunc func(string) abci.Application, -) ([]*State, *types.GenesisDoc, *cfg.Config, cleanupFunc) { - genDoc, privVals := factory.RandGenesisDoc(config, nValidators, false, testMinPower) +) ([]*State, *types.GenesisDoc, *config.Config, cleanupFunc) { + genDoc, privVals := factory.RandGenesisDoc(cfg, nValidators, false, testMinPower) css := make([]*State, nPeers) logger := consensusLogger() - var peer0Config *cfg.Config + var peer0Config *config.Config configRootDirs := make([]string, 0, nPeers) for i := 0; i < nPeers; i++ { state, _ := sm.MakeGenesisState(genDoc) @@ -799,7 +797,7 @@ func randConsensusNetWithPeers( } } - app := appFunc(path.Join(config.DBDir(), fmt.Sprintf("%s_%d", testName, i))) + app := appFunc(path.Join(cfg.DBDir(), fmt.Sprintf("%s_%d", testName, i))) vals := types.TM2PB.ValidatorUpdates(state.Validators) if _, ok := app.(*kvstore.PersistentKVStoreApplication); ok { // simulate handshake, receive app version. If don't do this, replay test will fail @@ -820,12 +818,12 @@ func randConsensusNetWithPeers( } func randGenesisState( - config *cfg.Config, + cfg *config.Config, numValidators int, randPower bool, minPower int64) (sm.State, []types.PrivValidator) { - genDoc, privValidators := factory.RandGenesisDoc(config, numValidators, randPower, minPower) + genDoc, privValidators := factory.RandGenesisDoc(cfg, numValidators, randPower, minPower) s0, _ := sm.MakeGenesisState(genDoc) return s0, privValidators } diff --git a/internal/consensus/mempool_test.go b/internal/consensus/mempool_test.go index 8eb1b3f60..58784a2ee 100644 --- a/internal/consensus/mempool_test.go +++ b/internal/consensus/mempool_test.go @@ -10,20 +10,19 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - dbm "github.com/tendermint/tm-db" "github.com/tendermint/tendermint/abci/example/code" abci "github.com/tendermint/tendermint/abci/types" - mempl "github.com/tendermint/tendermint/internal/mempool" + "github.com/tendermint/tendermint/internal/mempool" sm "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" ) // for testing -func assertMempool(txn txNotifier) mempl.Mempool { - return txn.(mempl.Mempool) +func assertMempool(txn txNotifier) mempool.Mempool { + return txn.(mempool.Mempool) } func TestMempoolNoProgressUntilTxsAvailable(t *testing.T) { @@ -113,7 +112,7 @@ func deliverTxsRange(cs *State, start, end int) { for i := start; i < end; i++ { txBytes := make([]byte, 8) binary.BigEndian.PutUint64(txBytes, uint64(i)) - err := assertMempool(cs.txNotifier).CheckTx(context.Background(), txBytes, nil, mempl.TxInfo{}) + err := assertMempool(cs.txNotifier).CheckTx(context.Background(), txBytes, nil, mempool.TxInfo{}) if err != nil { panic(fmt.Sprintf("Error after CheckTx: %v", err)) } @@ -179,7 +178,7 @@ func TestMempoolRmBadTx(t *testing.T) { return } checkTxRespCh <- struct{}{} - }, mempl.TxInfo{}) + }, mempool.TxInfo{}) if err != nil { t.Errorf("error after CheckTx: %v", err) return diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go index bb4f72d8c..a5f06c884 100644 --- a/internal/consensus/reactor_test.go +++ b/internal/consensus/reactor_test.go @@ -12,12 +12,13 @@ import ( "github.com/fortytw2/leaktest" "github.com/stretchr/testify/mock" "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" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/crypto/encoding" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/internal/mempool" mempoolv0 "github.com/tendermint/tendermint/internal/mempool/v0" @@ -31,7 +32,6 @@ import ( tmcons "github.com/tendermint/tendermint/proto/tendermint/consensus" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" - dbm "github.com/tendermint/tm-db" ) var ( @@ -273,11 +273,11 @@ func ensureBlockSyncStatus(t *testing.T, msg tmpubsub.Message, complete bool, he } func TestReactorBasic(t *testing.T) { - config := configSetup(t) + cfg := configSetup(t) n := 4 states, cleanup := randConsensusState(t, - config, n, "consensus_reactor_test", + cfg, n, "consensus_reactor_test", newMockTickerFunc(true), newKVStore) t.Cleanup(cleanup) @@ -316,14 +316,14 @@ func TestReactorBasic(t *testing.T) { } func TestReactorWithEvidence(t *testing.T) { - config := configSetup(t) + cfg := configSetup(t) n := 4 testName := "consensus_reactor_test" tickerFunc := newMockTickerFunc(true) appFunc := newKVStore - genDoc, privVals := factory.RandGenesisDoc(config, n, false, 30) + genDoc, privVals := factory.RandGenesisDoc(cfg, n, false, 30) states := make([]*State, n) logger := consensusLogger() @@ -360,7 +360,7 @@ func TestReactorWithEvidence(t *testing.T) { // everyone includes evidence of another double signing vIdx := (i + 1) % n - ev := types.NewMockDuplicateVoteEvidenceWithValidator(1, defaultTestTime, privVals[vIdx], config.ChainID()) + ev := types.NewMockDuplicateVoteEvidenceWithValidator(1, defaultTestTime, privVals[vIdx], cfg.ChainID()) evpool := &statemocks.EvidencePool{} evpool.On("CheckEvidence", mock.AnythingOfType("types.EvidenceList")).Return(nil) evpool.On("PendingEvidence", mock.AnythingOfType("int64")).Return([]types.Evidence{ @@ -412,17 +412,17 @@ func TestReactorWithEvidence(t *testing.T) { } func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) { - config := configSetup(t) + cfg := configSetup(t) n := 4 states, cleanup := randConsensusState( t, - config, + cfg, n, "consensus_reactor_test", newMockTickerFunc(true), newKVStore, - func(c *cfg.Config) { + func(c *config.Config) { c.Consensus.CreateEmptyBlocks = false }, ) @@ -462,11 +462,11 @@ func TestReactorCreatesBlockWhenEmptyBlocksFalse(t *testing.T) { } func TestReactorRecordsVotesAndBlockParts(t *testing.T) { - config := configSetup(t) + cfg := configSetup(t) n := 4 states, cleanup := randConsensusState(t, - config, n, "consensus_reactor_test", + cfg, n, "consensus_reactor_test", newMockTickerFunc(true), newKVStore) t.Cleanup(cleanup) @@ -521,12 +521,12 @@ func TestReactorRecordsVotesAndBlockParts(t *testing.T) { } func TestReactorVotingPowerChange(t *testing.T) { - config := configSetup(t) + cfg := configSetup(t) n := 4 states, cleanup := randConsensusState( t, - config, + cfg, n, "consensus_voting_power_changes_test", newMockTickerFunc(true), @@ -573,7 +573,7 @@ func TestReactorVotingPowerChange(t *testing.T) { val1PubKey, err := states[0].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - val1PubKeyABCI, err := cryptoenc.PubKeyToProto(val1PubKey) + val1PubKeyABCI, err := encoding.PubKeyToProto(val1PubKey) require.NoError(t, err) updateValidatorTx := kvstore.MakeValSetChangeTx(val1PubKeyABCI, 25) @@ -622,12 +622,12 @@ func TestReactorVotingPowerChange(t *testing.T) { } func TestReactorValidatorSetChanges(t *testing.T) { - config := configSetup(t) + cfg := configSetup(t) nPeers := 7 nVals := 4 states, _, _, cleanup := randConsensusNetWithPeers( - config, + cfg, nVals, nPeers, "consensus_val_set_changes_test", @@ -668,7 +668,7 @@ func TestReactorValidatorSetChanges(t *testing.T) { newValidatorPubKey1, err := states[nVals].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - valPubKey1ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey1) + valPubKey1ABCI, err := encoding.PubKeyToProto(newValidatorPubKey1) require.NoError(t, err) newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower) @@ -701,7 +701,7 @@ func TestReactorValidatorSetChanges(t *testing.T) { updateValidatorPubKey1, err := states[nVals].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - updatePubKey1ABCI, err := cryptoenc.PubKeyToProto(updateValidatorPubKey1) + updatePubKey1ABCI, err := encoding.PubKeyToProto(updateValidatorPubKey1) require.NoError(t, err) updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25) @@ -721,7 +721,7 @@ func TestReactorValidatorSetChanges(t *testing.T) { newValidatorPubKey2, err := states[nVals+1].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - newVal2ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey2) + newVal2ABCI, err := encoding.PubKeyToProto(newValidatorPubKey2) require.NoError(t, err) newValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, testMinPower) @@ -729,7 +729,7 @@ func TestReactorValidatorSetChanges(t *testing.T) { newValidatorPubKey3, err := states[nVals+2].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - newVal3ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey3) + newVal3ABCI, err := encoding.PubKeyToProto(newValidatorPubKey3) require.NoError(t, err) newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower) diff --git a/internal/consensus/replay_file.go b/internal/consensus/replay_file.go index a3a39fbbc..47ed61874 100644 --- a/internal/consensus/replay_file.go +++ b/internal/consensus/replay_file.go @@ -12,7 +12,7 @@ import ( dbm "github.com/tendermint/tm-db" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/internal/proxy" sm "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/libs/log" @@ -31,8 +31,8 @@ const ( // replay messages interactively or all at once // replay the wal file -func RunReplayFile(config cfg.BaseConfig, csConfig *cfg.ConsensusConfig, console bool) { - consensusState := newConsensusStateForReplay(config, csConfig) +func RunReplayFile(cfg config.BaseConfig, csConfig *config.ConsensusConfig, console bool) { + consensusState := newConsensusStateForReplay(cfg, csConfig) if err := consensusState.ReplayFile(csConfig.WalFile(), console); err != nil { tmos.Exit(fmt.Sprintf("Error during consensus replay: %v", err)) @@ -286,22 +286,22 @@ func (pb *playback) replayConsoleLoop() int { //-------------------------------------------------------------------------------- // convenience for replay mode -func newConsensusStateForReplay(config cfg.BaseConfig, csConfig *cfg.ConsensusConfig) *State { - dbType := dbm.BackendType(config.DBBackend) +func newConsensusStateForReplay(cfg config.BaseConfig, csConfig *config.ConsensusConfig) *State { + dbType := dbm.BackendType(cfg.DBBackend) // Get BlockStore - blockStoreDB, err := dbm.NewDB("blockstore", dbType, config.DBDir()) + blockStoreDB, err := dbm.NewDB("blockstore", dbType, cfg.DBDir()) if err != nil { tmos.Exit(err.Error()) } blockStore := store.NewBlockStore(blockStoreDB) // Get State - stateDB, err := dbm.NewDB("state", dbType, config.DBDir()) + stateDB, err := dbm.NewDB("state", dbType, cfg.DBDir()) if err != nil { tmos.Exit(err.Error()) } stateStore := sm.NewStore(stateDB) - gdoc, err := sm.MakeGenesisDocFromFile(config.GenesisFile()) + gdoc, err := sm.MakeGenesisDocFromFile(cfg.GenesisFile()) if err != nil { tmos.Exit(err.Error()) } @@ -311,7 +311,7 @@ func newConsensusStateForReplay(config cfg.BaseConfig, csConfig *cfg.ConsensusCo } // Create proxyAppConn connection (consensus, mempool, query) - clientCreator, _ := proxy.DefaultClientCreator(config.ProxyApp, config.ABCI, config.DBDir()) + clientCreator, _ := proxy.DefaultClientCreator(cfg.ProxyApp, cfg.ABCI, cfg.DBDir()) proxyApp := proxy.NewAppConns(clientCreator) err = proxyApp.Start() if err != nil { diff --git a/internal/consensus/replay_stubs.go b/internal/consensus/replay_stubs.go index 7a3d2c34a..361ac6ec8 100644 --- a/internal/consensus/replay_stubs.go +++ b/internal/consensus/replay_stubs.go @@ -6,7 +6,7 @@ import ( 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/mempool" "github.com/tendermint/tendermint/internal/proxy" tmstate "github.com/tendermint/tendermint/proto/tendermint/state" "github.com/tendermint/tendermint/types" @@ -16,12 +16,12 @@ import ( type emptyMempool struct{} -var _ mempl.Mempool = emptyMempool{} +var _ mempool.Mempool = emptyMempool{} func (emptyMempool) Lock() {} func (emptyMempool) Unlock() {} func (emptyMempool) Size() int { return 0 } -func (emptyMempool) CheckTx(_ context.Context, _ types.Tx, _ func(*abci.Response), _ mempl.TxInfo) error { +func (emptyMempool) CheckTx(_ context.Context, _ types.Tx, _ func(*abci.Response), _ mempool.TxInfo) error { return nil } func (emptyMempool) ReapMaxBytesMaxGas(_, _ int64) types.Txs { return types.Txs{} } @@ -30,8 +30,8 @@ func (emptyMempool) Update( _ int64, _ types.Txs, _ []*abci.ResponseDeliverTx, - _ mempl.PreCheckFunc, - _ mempl.PostCheckFunc, + _ mempool.PreCheckFunc, + _ mempool.PostCheckFunc, ) error { return nil } diff --git a/internal/consensus/replay_test.go b/internal/consensus/replay_test.go index c5623e36d..248cf6da3 100644 --- a/internal/consensus/replay_test.go +++ b/internal/consensus/replay_test.go @@ -22,10 +22,10 @@ import ( 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/config" "github.com/tendermint/tendermint/crypto" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" - mempl "github.com/tendermint/tendermint/internal/mempool" + "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/internal/mempool" "github.com/tendermint/tendermint/internal/proxy" sm "github.com/tendermint/tendermint/internal/state" sf "github.com/tendermint/tendermint/internal/state/test/factory" @@ -54,7 +54,7 @@ import ( // and which ones we need the wal for - then we'd also be able to only flush the // wal writer when we need to, instead of with every message. -func startNewStateAndWaitForBlock(t *testing.T, consensusReplayConfig *cfg.Config, +func startNewStateAndWaitForBlock(t *testing.T, consensusReplayConfig *config.Config, lastBlockHeight int64, blockDB dbm.DB, stateStore sm.Store) { logger := log.TestingLogger() state, err := sm.MakeGenesisStateFromFile(consensusReplayConfig.GenesisFile()) @@ -103,7 +103,7 @@ func sendTxs(ctx context.Context, cs *State) { return default: tx := []byte{byte(i)} - if err := assertMempool(cs.txNotifier).CheckTx(context.Background(), tx, nil, mempl.TxInfo{}); err != nil { + if err := assertMempool(cs.txNotifier).CheckTx(context.Background(), tx, nil, mempool.TxInfo{}); err != nil { panic(err) } i++ @@ -137,7 +137,7 @@ func TestWALCrash(t *testing.T) { } } -func crashWALandCheckLiveness(t *testing.T, consensusReplayConfig *cfg.Config, +func crashWALandCheckLiveness(t *testing.T, consensusReplayConfig *config.Config, initFn func(dbm.DB, *State, context.Context), heightToStop int64) { walPanicked := make(chan error) crashingWal := &crashingWAL{panicCh: walPanicked, heightToStop: heightToStop} @@ -286,12 +286,12 @@ func (w *crashingWAL) Wait() { w.next.Wait() } //------------------------------------------------------------------------------------------ type simulatorTestSuite struct { GenesisState sm.State - Config *cfg.Config + Config *config.Config Chain []*types.Block Commits []*types.Commit CleanupFunc cleanupFunc - Mempool mempl.Mempool + Mempool mempool.Mempool Evpool sm.EvidencePool } @@ -311,7 +311,7 @@ var modes = []uint{0, 1, 2, 3} // This is actually not a test, it's for storing validator change tx data for testHandshakeReplay func setupSimulator(t *testing.T) *simulatorTestSuite { t.Helper() - config := configSetup(t) + cfg := configSetup(t) sim := &simulatorTestSuite{ Mempool: emptyMempool{}, @@ -321,14 +321,14 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { nPeers := 7 nVals := 4 - css, genDoc, config, cleanup := randConsensusNetWithPeers( - config, + css, genDoc, cfg, cleanup := randConsensusNetWithPeers( + cfg, nVals, nPeers, "replay_test", newMockTickerFunc(true), newPersistentKVStoreWithPath) - sim.Config = config + sim.Config = cfg sim.GenesisState, _ = sm.MakeGenesisState(genDoc) sim.CleanupFunc = cleanup @@ -361,10 +361,10 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { incrementHeight(vss...) newValidatorPubKey1, err := css[nVals].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - valPubKey1ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey1) + valPubKey1ABCI, err := encoding.PubKeyToProto(newValidatorPubKey1) require.NoError(t, err) newValidatorTx1 := kvstore.MakeValSetChangeTx(valPubKey1ABCI, testMinPower) - err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), newValidatorTx1, nil, mempl.TxInfo{}) + err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), newValidatorTx1, nil, mempool.TxInfo{}) assert.Nil(t, err) propBlock, _ := css[0].createProposalBlock() // changeProposer(t, cs1, vs2) propBlockParts := propBlock.MakePartSet(partSize) @@ -372,7 +372,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { proposal := types.NewProposal(vss[1].Height, round, -1, blockID) p := proposal.ToProto() - if err := vss[1].SignProposal(context.Background(), config.ChainID(), p); err != nil { + if err := vss[1].SignProposal(context.Background(), cfg.ChainID(), p); err != nil { t.Fatal("failed to sign bad proposal", err) } proposal.Signature = p.Signature @@ -393,10 +393,10 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { incrementHeight(vss...) updateValidatorPubKey1, err := css[nVals].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - updatePubKey1ABCI, err := cryptoenc.PubKeyToProto(updateValidatorPubKey1) + updatePubKey1ABCI, err := encoding.PubKeyToProto(updateValidatorPubKey1) require.NoError(t, err) updateValidatorTx1 := kvstore.MakeValSetChangeTx(updatePubKey1ABCI, 25) - err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), updateValidatorTx1, nil, mempl.TxInfo{}) + err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), updateValidatorTx1, nil, mempool.TxInfo{}) assert.Nil(t, err) propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) propBlockParts = propBlock.MakePartSet(partSize) @@ -404,7 +404,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { proposal = types.NewProposal(vss[2].Height, round, -1, blockID) p = proposal.ToProto() - if err := vss[2].SignProposal(context.Background(), config.ChainID(), p); err != nil { + if err := vss[2].SignProposal(context.Background(), cfg.ChainID(), p); err != nil { t.Fatal("failed to sign bad proposal", err) } proposal.Signature = p.Signature @@ -425,17 +425,17 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { incrementHeight(vss...) newValidatorPubKey2, err := css[nVals+1].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - newVal2ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey2) + newVal2ABCI, err := encoding.PubKeyToProto(newValidatorPubKey2) require.NoError(t, err) newValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, testMinPower) - err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), newValidatorTx2, nil, mempl.TxInfo{}) + err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), newValidatorTx2, nil, mempool.TxInfo{}) assert.Nil(t, err) newValidatorPubKey3, err := css[nVals+2].privValidator.GetPubKey(context.Background()) require.NoError(t, err) - newVal3ABCI, err := cryptoenc.PubKeyToProto(newValidatorPubKey3) + newVal3ABCI, err := encoding.PubKeyToProto(newValidatorPubKey3) require.NoError(t, err) newValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, testMinPower) - err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), newValidatorTx3, nil, mempl.TxInfo{}) + err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), newValidatorTx3, nil, mempool.TxInfo{}) assert.Nil(t, err) propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) propBlockParts = propBlock.MakePartSet(partSize) @@ -463,7 +463,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { proposal = types.NewProposal(vss[3].Height, round, -1, blockID) p = proposal.ToProto() - if err := vss[3].SignProposal(context.Background(), config.ChainID(), p); err != nil { + if err := vss[3].SignProposal(context.Background(), cfg.ChainID(), p); err != nil { t.Fatal("failed to sign bad proposal", err) } proposal.Signature = p.Signature @@ -475,7 +475,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { ensureNewProposal(proposalCh, height, round) removeValidatorTx2 := kvstore.MakeValSetChangeTx(newVal2ABCI, 0) - err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), removeValidatorTx2, nil, mempl.TxInfo{}) + err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), removeValidatorTx2, nil, mempool.TxInfo{}) assert.Nil(t, err) rs = css[0].GetRoundState() @@ -514,7 +514,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { height++ incrementHeight(vss...) removeValidatorTx3 := kvstore.MakeValSetChangeTx(newVal3ABCI, 0) - err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), removeValidatorTx3, nil, mempl.TxInfo{}) + err = assertMempool(css[0].txNotifier).CheckTx(context.Background(), removeValidatorTx3, nil, mempool.TxInfo{}) assert.Nil(t, err) propBlock, _ = css[0].createProposalBlock() // changeProposer(t, cs1, vs2) propBlockParts = propBlock.MakePartSet(partSize) @@ -526,7 +526,7 @@ func setupSimulator(t *testing.T) *simulatorTestSuite { selfIndex = valIndexFn(0) proposal = types.NewProposal(vss[1].Height, round, -1, blockID) p = proposal.ToProto() - if err := vss[1].SignProposal(context.Background(), config.ChainID(), p); err != nil { + if err := vss[1].SignProposal(context.Background(), cfg.ChainID(), p); err != nil { t.Fatal("failed to sign bad proposal", err) } proposal.Signature = p.Signature @@ -611,8 +611,8 @@ func TestHandshakeReplayNone(t *testing.T) { // Test mockProxyApp should not panic when app return ABCIResponses with some empty ResponseDeliverTx func TestMockProxyApp(t *testing.T) { sim := setupSimulator(t) // setup config and simulator - config := sim.Config - assert.NotNil(t, config) + cfg := sim.Config + assert.NotNil(t, cfg) logger := log.TestingLogger() var validTxs, invalidTxs = 0, 0 @@ -687,7 +687,7 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod var stateDB dbm.DB var genesisState sm.State - config := sim.Config + cfg := sim.Config if testValidatorsChange { testConfig := ResetConfig(fmt.Sprintf("%s_%v_m", t.Name(), mode)) @@ -695,19 +695,19 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod stateDB = dbm.NewMemDB() genesisState = sim.GenesisState - config = sim.Config + cfg = sim.Config chain = append([]*types.Block{}, sim.Chain...) // copy chain commits = sim.Commits - store = newMockBlockStore(config, genesisState.ConsensusParams) + store = newMockBlockStore(cfg, genesisState.ConsensusParams) } else { // test single node testConfig := ResetConfig(fmt.Sprintf("%s_%v_s", t.Name(), mode)) defer func() { _ = os.RemoveAll(testConfig.RootDir) }() walBody, err := WALWithNBlocks(t, numBlocks) require.NoError(t, err) walFile := tempWALWithData(walBody) - config.Consensus.SetWalFile(walFile) + cfg.Consensus.SetWalFile(walFile) - privVal, err := privval.LoadFilePV(config.PrivValidator.KeyFile(), config.PrivValidator.StateFile()) + privVal, err := privval.LoadFilePV(cfg.PrivValidator.KeyFile(), cfg.PrivValidator.StateFile()) require.NoError(t, err) wal, err := NewWAL(walFile) @@ -724,7 +724,7 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod require.NoError(t, err) pubKey, err := privVal.GetPubKey(context.Background()) require.NoError(t, err) - stateDB, genesisState, store = stateAndStore(config, pubKey, kvstore.ProtocolVersion) + stateDB, genesisState, store = stateAndStore(cfg, pubKey, kvstore.ProtocolVersion) } stateStore := sm.NewStore(stateDB) @@ -733,12 +733,12 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod state := genesisState.Copy() // run the chain through state.ApplyBlock to build up the tendermint state - state = buildTMStateFromChain(config, sim.Mempool, sim.Evpool, stateStore, state, chain, nBlocks, mode, store) + state = buildTMStateFromChain(cfg, sim.Mempool, sim.Evpool, stateStore, state, chain, nBlocks, mode, store) latestAppHash := state.AppHash // make a new client creator kvstoreApp := kvstore.NewPersistentKVStoreApplication( - filepath.Join(config.DBDir(), fmt.Sprintf("replay_test_%d_%d_a_r%d", nBlocks, mode, rand.Int()))) + filepath.Join(cfg.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) @@ -763,7 +763,7 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod } // now start the app using the handshake - it should sync - genDoc, _ := sm.MakeGenesisDocFromFile(config.GenesisFile()) + genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile()) handshaker := NewHandshaker(stateStore, state, store, genDoc) proxyApp := proxy.NewAppConns(clientCreator2) if err := proxyApp.Start(); err != nil { @@ -811,7 +811,7 @@ func testHandshakeReplay(t *testing.T, sim *simulatorTestSuite, nBlocks int, mod } func applyBlock(stateStore sm.Store, - mempool mempl.Mempool, + mempool mempool.Mempool, evpool sm.EvidencePool, st sm.State, blk *types.Block, @@ -831,7 +831,7 @@ func applyBlock(stateStore sm.Store, func buildAppStateFromChain( proxyApp proxy.AppConns, stateStore sm.Store, - mempool mempl.Mempool, + mempool mempool.Mempool, evpool sm.EvidencePool, state sm.State, chain []*types.Block, @@ -878,8 +878,8 @@ func buildAppStateFromChain( } func buildTMStateFromChain( - config *cfg.Config, - mempool mempl.Mempool, + cfg *config.Config, + mempool mempool.Mempool, evpool sm.EvidencePool, stateStore sm.Store, state sm.State, @@ -889,7 +889,7 @@ func buildTMStateFromChain( blockStore *mockBlockStore) sm.State { // run the whole chain against this client to build up the tendermint state kvstoreApp := kvstore.NewPersistentKVStoreApplication( - filepath.Join(config.DBDir(), fmt.Sprintf("replay_test_%d_%d_t", nBlocks, mode))) + filepath.Join(cfg.DBDir(), fmt.Sprintf("replay_test_%d_%d_t", nBlocks, mode))) defer kvstoreApp.Close() clientCreator := abciclient.NewLocalCreator(kvstoreApp) @@ -938,16 +938,16 @@ func TestHandshakePanicsIfAppReturnsWrongAppHash(t *testing.T) { // - 0x01 // - 0x02 // - 0x03 - config := ResetConfig("handshake_test_") - t.Cleanup(func() { os.RemoveAll(config.RootDir) }) - privVal, err := privval.LoadFilePV(config.PrivValidator.KeyFile(), config.PrivValidator.StateFile()) + cfg := ResetConfig("handshake_test_") + t.Cleanup(func() { os.RemoveAll(cfg.RootDir) }) + privVal, err := privval.LoadFilePV(cfg.PrivValidator.KeyFile(), cfg.PrivValidator.StateFile()) require.NoError(t, err) const appVersion = 0x0 pubKey, err := privVal.GetPubKey(context.Background()) require.NoError(t, err) - stateDB, state, store := stateAndStore(config, pubKey, appVersion) + stateDB, state, store := stateAndStore(cfg, pubKey, appVersion) stateStore := sm.NewStore(stateDB) - genDoc, _ := sm.MakeGenesisDocFromFile(config.GenesisFile()) + genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile()) state.LastValidators = state.Validators.Copy() // mode = 0 for committing all the blocks blocks := sf.MakeBlocks(3, &state, privVal) @@ -1153,14 +1153,14 @@ func readPieceFromWAL(msg *TimedWALMessage) interface{} { // fresh state and mock store func stateAndStore( - config *cfg.Config, + cfg *config.Config, pubKey crypto.PubKey, appVersion uint64) (dbm.DB, sm.State, *mockBlockStore) { stateDB := dbm.NewMemDB() stateStore := sm.NewStore(stateDB) - state, _ := sm.MakeGenesisStateFromFile(config.GenesisFile()) + state, _ := sm.MakeGenesisStateFromFile(cfg.GenesisFile()) state.Version.Consensus.App = appVersion - store := newMockBlockStore(config, state.ConsensusParams) + store := newMockBlockStore(cfg, state.ConsensusParams) if err := stateStore.Save(state); err != nil { panic(err) } @@ -1171,7 +1171,7 @@ func stateAndStore( // mock block store type mockBlockStore struct { - config *cfg.Config + cfg *config.Config params types.ConsensusParams chain []*types.Block commits []*types.Commit @@ -1179,8 +1179,8 @@ type mockBlockStore struct { } // TODO: NewBlockStore(db.NewMemDB) ... -func newMockBlockStore(config *cfg.Config, params types.ConsensusParams) *mockBlockStore { - return &mockBlockStore{config, params, nil, nil, 0} +func newMockBlockStore(cfg *config.Config, params types.ConsensusParams) *mockBlockStore { + return &mockBlockStore{cfg, params, nil, nil, 0} } func (bs *mockBlockStore) Height() int64 { return int64(len(bs.chain)) } @@ -1228,20 +1228,20 @@ func TestHandshakeUpdatesValidators(t *testing.T) { app := &initChainApp{vals: types.TM2PB.ValidatorUpdates(vals)} clientCreator := abciclient.NewLocalCreator(app) - config := ResetConfig("handshake_test_") - t.Cleanup(func() { _ = os.RemoveAll(config.RootDir) }) + cfg := ResetConfig("handshake_test_") + t.Cleanup(func() { _ = os.RemoveAll(cfg.RootDir) }) - privVal, err := privval.LoadFilePV(config.PrivValidator.KeyFile(), config.PrivValidator.StateFile()) + privVal, err := privval.LoadFilePV(cfg.PrivValidator.KeyFile(), cfg.PrivValidator.StateFile()) require.NoError(t, err) pubKey, err := privVal.GetPubKey(context.Background()) require.NoError(t, err) - stateDB, state, store := stateAndStore(config, pubKey, 0x0) + stateDB, state, store := stateAndStore(cfg, pubKey, 0x0) stateStore := sm.NewStore(stateDB) oldValAddr := state.Validators.Validators[0].Address // now start the app using the handshake - it should sync - genDoc, _ := sm.MakeGenesisDocFromFile(config.GenesisFile()) + genDoc, _ := sm.MakeGenesisDocFromFile(cfg.GenesisFile()) handshaker := NewHandshaker(stateStore, state, store, genDoc) proxyApp := proxy.NewAppConns(clientCreator) if err := proxyApp.Start(); err != nil { diff --git a/internal/consensus/state.go b/internal/consensus/state.go index 165318c9c..46bacf5cc 100644 --- a/internal/consensus/state.go +++ b/internal/consensus/state.go @@ -12,7 +12,7 @@ import ( "github.com/gogo/protobuf/proto" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto" cstypes "github.com/tendermint/tendermint/internal/consensus/types" "github.com/tendermint/tendermint/internal/libs/fail" @@ -80,7 +80,7 @@ type State struct { service.BaseService // config details - config *cfg.ConsensusConfig + config *config.ConsensusConfig privValidator types.PrivValidator // for signing votes privValidatorType types.PrivValidatorType @@ -152,7 +152,7 @@ type StateOption func(*State) // NewState returns a new State. func NewState( - config *cfg.ConsensusConfig, + cfg *config.ConsensusConfig, state sm.State, blockExec *sm.BlockExecutor, blockStore sm.BlockStore, @@ -161,7 +161,7 @@ func NewState( options ...StateOption, ) *State { cs := &State{ - config: config, + config: cfg, blockExec: blockExec, blockStore: blockStore, txNotifier: txNotifier, diff --git a/internal/consensus/types/height_vote_set_test.go b/internal/consensus/types/height_vote_set_test.go index a9e309b4f..b3830a3f6 100644 --- a/internal/consensus/types/height_vote_set_test.go +++ b/internal/consensus/types/height_vote_set_test.go @@ -6,7 +6,7 @@ import ( "os" "testing" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto/tmhash" "github.com/tendermint/tendermint/internal/test/factory" tmrand "github.com/tendermint/tendermint/libs/rand" @@ -15,19 +15,19 @@ import ( "github.com/tendermint/tendermint/types" ) -var config *cfg.Config // NOTE: must be reset for each _test.go file +var cfg *config.Config // NOTE: must be reset for each _test.go file func TestMain(m *testing.M) { - config = cfg.ResetTestRoot("consensus_height_vote_set_test") + cfg = config.ResetTestRoot("consensus_height_vote_set_test") code := m.Run() - os.RemoveAll(config.RootDir) + os.RemoveAll(cfg.RootDir) os.Exit(code) } func TestPeerCatchupRounds(t *testing.T) { valSet, privVals := factory.RandValidatorSet(10, 1) - hvs := NewHeightVoteSet(config.ChainID(), 1, valSet) + hvs := NewHeightVoteSet(cfg.ChainID(), 1, valSet) vote999_0 := makeVoteHR(t, 1, 0, 999, privVals) added, err := hvs.AddVote(vote999_0, "peer1") @@ -75,7 +75,7 @@ func makeVoteHR(t *testing.T, height int64, valIndex, round int32, privVals []ty Type: tmproto.PrecommitType, BlockID: types.BlockID{Hash: randBytes, PartSetHeader: types.PartSetHeader{}}, } - chainID := config.ChainID() + chainID := cfg.ChainID() v := vote.ToProto() err = privVal.SignVote(context.Background(), chainID, v) diff --git a/internal/consensus/wal_generator.go b/internal/consensus/wal_generator.go index b92230d2c..ccc6685fc 100644 --- a/internal/consensus/wal_generator.go +++ b/internal/consensus/wal_generator.go @@ -11,11 +11,11 @@ import ( "time" "github.com/stretchr/testify/require" - db "github.com/tendermint/tm-db" + 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/config" "github.com/tendermint/tendermint/internal/proxy" sm "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/libs/log" @@ -30,9 +30,9 @@ import ( // (byteBufferWAL) and waits until numBlocks are created. // If the node fails to produce given numBlocks, it returns an error. func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) { - config := getConfig(t) + cfg := getConfig(t) - app := kvstore.NewPersistentKVStoreApplication(filepath.Join(config.DBDir(), "wal_generator")) + app := kvstore.NewPersistentKVStoreApplication(filepath.Join(cfg.DBDir(), "wal_generator")) t.Cleanup(func() { require.NoError(t, app.Close()) }) logger := log.TestingLogger().With("wal_generator", "wal_generator") @@ -41,17 +41,17 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) { // COPY PASTE FROM node.go WITH A FEW MODIFICATIONS // NOTE: we can't import node package because of circular dependency. // NOTE: we don't do handshake so need to set state.Version.Consensus.App directly. - privValidatorKeyFile := config.PrivValidator.KeyFile() - privValidatorStateFile := config.PrivValidator.StateFile() + privValidatorKeyFile := cfg.PrivValidator.KeyFile() + privValidatorStateFile := cfg.PrivValidator.StateFile() privValidator, err := privval.LoadOrGenFilePV(privValidatorKeyFile, privValidatorStateFile) if err != nil { return err } - genDoc, err := types.GenesisDocFromFile(config.GenesisFile()) + genDoc, err := types.GenesisDocFromFile(cfg.GenesisFile()) if err != nil { return fmt.Errorf("failed to read genesis file: %w", err) } - blockStoreDB := db.NewMemDB() + blockStoreDB := dbm.NewMemDB() stateDB := blockStoreDB stateStore := sm.NewStore(stateDB) state, err := sm.MakeGenesisState(genDoc) @@ -89,7 +89,7 @@ func WALGenerateNBlocks(t *testing.T, wr io.Writer, numBlocks int) (err error) { mempool := emptyMempool{} evpool := sm.EmptyEvidencePool{} blockExec := sm.NewBlockExecutor(stateStore, log.TestingLogger(), proxyApp.Consensus(), mempool, evpool, blockStore) - consensusState := NewState(config.Consensus, state.Copy(), blockExec, blockStore, mempool, evpool) + consensusState := NewState(cfg.Consensus, state.Copy(), blockExec, blockStore, mempool, evpool) consensusState.SetLogger(logger) consensusState.SetEventBus(eventBus) if privValidator != nil && privValidator != (*privval.FilePV)(nil) { @@ -153,8 +153,8 @@ func makeAddrs() (string, string, string) { } // getConfig returns a config for test cases -func getConfig(t *testing.T) *cfg.Config { - c := cfg.ResetTestRoot(t.Name()) +func getConfig(t *testing.T) *config.Config { + c := config.ResetTestRoot(t.Name()) // and we use random ports to run in parallel tm, rpc, grpc := makeAddrs() diff --git a/internal/evidence/verify_test.go b/internal/evidence/verify_test.go index 2bb3d8008..df1642f82 100644 --- a/internal/evidence/verify_test.go +++ b/internal/evidence/verify_test.go @@ -8,7 +8,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - dbm "github.com/tendermint/tm-db" "github.com/tendermint/tendermint/crypto" diff --git a/internal/mempool/mock/mempool.go b/internal/mempool/mock/mempool.go index 5749d2d3c..bf9ce8bd0 100644 --- a/internal/mempool/mock/mempool.go +++ b/internal/mempool/mock/mempool.go @@ -5,19 +5,19 @@ import ( 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/mempool" "github.com/tendermint/tendermint/types" ) // Mempool is an empty implementation of a Mempool, useful for testing. type Mempool struct{} -var _ mempl.Mempool = Mempool{} +var _ mempool.Mempool = Mempool{} func (Mempool) Lock() {} func (Mempool) Unlock() {} func (Mempool) Size() int { return 0 } -func (Mempool) CheckTx(_ context.Context, _ types.Tx, _ func(*abci.Response), _ mempl.TxInfo) error { +func (Mempool) CheckTx(_ context.Context, _ types.Tx, _ func(*abci.Response), _ mempool.TxInfo) error { return nil } func (Mempool) ReapMaxBytesMaxGas(_, _ int64) types.Txs { return types.Txs{} } @@ -26,8 +26,8 @@ func (Mempool) Update( _ int64, _ types.Txs, _ []*abci.ResponseDeliverTx, - _ mempl.PreCheckFunc, - _ mempl.PostCheckFunc, + _ mempool.PreCheckFunc, + _ mempool.PostCheckFunc, ) error { return nil } diff --git a/internal/mempool/v0/clist_mempool.go b/internal/mempool/v0/clist_mempool.go index 9edf067de..f3571ede0 100644 --- a/internal/mempool/v0/clist_mempool.go +++ b/internal/mempool/v0/clist_mempool.go @@ -8,7 +8,7 @@ import ( "sync/atomic" abci "github.com/tendermint/tendermint/abci/types" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/internal/libs/clist" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/internal/mempool" @@ -32,7 +32,7 @@ type CListMempool struct { notifiedTxsAvailable bool txsAvailable chan struct{} // fires once for each height, when the mempool is not empty - config *cfg.MempoolConfig + config *config.MempoolConfig // Exclusive mutex for Update method to prevent concurrent execution of // CheckTx or ReapMaxBytesMaxGas(ReapMaxTxs) methods. @@ -69,14 +69,14 @@ type CListMempoolOption func(*CListMempool) // NewCListMempool returns a new mempool with the given configuration and // connection to an application. func NewCListMempool( - config *cfg.MempoolConfig, + cfg *config.MempoolConfig, proxyAppConn proxy.AppConnMempool, height int64, options ...CListMempoolOption, ) *CListMempool { mp := &CListMempool{ - config: config, + config: cfg, proxyAppConn: proxyAppConn, txs: clist.New(), height: height, @@ -86,8 +86,8 @@ func NewCListMempool( metrics: mempool.NopMetrics(), } - if config.CacheSize > 0 { - mp.cache = mempool.NewLRUTxCache(config.CacheSize) + if cfg.CacheSize > 0 { + mp.cache = mempool.NewLRUTxCache(cfg.CacheSize) } else { mp.cache = mempool.NopTxCache{} } diff --git a/internal/mempool/v0/clist_mempool_test.go b/internal/mempool/v0/clist_mempool_test.go index 6d023b5f6..e55942e48 100644 --- a/internal/mempool/v0/clist_mempool_test.go +++ b/internal/mempool/v0/clist_mempool_test.go @@ -19,7 +19,7 @@ import ( "github.com/tendermint/tendermint/abci/example/kvstore" abciserver "github.com/tendermint/tendermint/abci/server" abci "github.com/tendermint/tendermint/abci/types" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/internal/mempool" "github.com/tendermint/tendermint/libs/log" tmrand "github.com/tendermint/tendermint/libs/rand" @@ -32,10 +32,10 @@ import ( type cleanupFunc func() func newMempoolWithApp(cc abciclient.Creator) (*CListMempool, cleanupFunc) { - return newMempoolWithAppAndConfig(cc, cfg.ResetTestRoot("mempool_test")) + return newMempoolWithAppAndConfig(cc, config.ResetTestRoot("mempool_test")) } -func newMempoolWithAppAndConfig(cc abciclient.Creator, config *cfg.Config) (*CListMempool, cleanupFunc) { +func newMempoolWithAppAndConfig(cc abciclient.Creator, cfg *config.Config) (*CListMempool, cleanupFunc) { appConnMem, _ := cc() appConnMem.SetLogger(log.TestingLogger().With("module", "abci-client", "connection", "mempool")) err := appConnMem.Start() @@ -43,10 +43,10 @@ func newMempoolWithAppAndConfig(cc abciclient.Creator, config *cfg.Config) (*CLi panic(err) } - mp := NewCListMempool(config.Mempool, appConnMem, 0) + mp := NewCListMempool(cfg.Mempool, appConnMem, 0) mp.SetLogger(log.TestingLogger()) - return mp, func() { os.RemoveAll(config.RootDir) } + return mp, func() { os.RemoveAll(cfg.RootDir) } } func ensureNoFire(t *testing.T, ch <-chan struct{}, timeoutMS int) { @@ -217,7 +217,7 @@ func TestMempoolUpdate(t *testing.T) { func TestMempool_KeepInvalidTxsInCache(t *testing.T) { app := kvstore.NewApplication() cc := abciclient.NewLocalCreator(app) - wcfg := cfg.DefaultConfig() + wcfg := config.DefaultConfig() wcfg.Mempool.KeepInvalidTxsInCache = true mp, cleanup := newMempoolWithAppAndConfig(cc, wcfg) defer cleanup() @@ -465,9 +465,9 @@ func TestMempool_CheckTxChecksTxSize(t *testing.T) { func TestMempoolTxsBytes(t *testing.T) { app := kvstore.NewApplication() cc := abciclient.NewLocalCreator(app) - config := cfg.ResetTestRoot("mempool_test") - config.Mempool.MaxTxsBytes = 10 - mp, cleanup := newMempoolWithAppAndConfig(cc, config) + cfg := config.ResetTestRoot("mempool_test") + cfg.Mempool.MaxTxsBytes = 10 + mp, cleanup := newMempoolWithAppAndConfig(cc, cfg) defer cleanup() // 1. zero by default @@ -564,8 +564,8 @@ func TestMempoolRemoteAppConcurrency(t *testing.T) { t.Error(err) } }) - config := cfg.ResetTestRoot("mempool_test") - mp, cleanup := newMempoolWithAppAndConfig(cc, config) + cfg := config.ResetTestRoot("mempool_test") + mp, cleanup := newMempoolWithAppAndConfig(cc, cfg) defer cleanup() // generate small number of txs @@ -577,7 +577,7 @@ func TestMempoolRemoteAppConcurrency(t *testing.T) { } // simulate a group of peers sending them over and over - N := config.Mempool.Size + N := cfg.Mempool.Size maxPeers := 5 for i := 0; i < N; i++ { peerID := mrand.Intn(maxPeers) diff --git a/internal/mempool/v0/reactor.go b/internal/mempool/v0/reactor.go index 29dec5833..b8aac3b5c 100644 --- a/internal/mempool/v0/reactor.go +++ b/internal/mempool/v0/reactor.go @@ -8,7 +8,7 @@ import ( "sync" "time" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/internal/libs/clist" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/internal/mempool" @@ -37,7 +37,7 @@ type PeerManager interface { type Reactor struct { service.BaseService - config *cfg.MempoolConfig + cfg *config.MempoolConfig mempool *CListMempool ids *mempool.MempoolIDs @@ -61,7 +61,7 @@ type Reactor struct { // NewReactor returns a reference to a new reactor. func NewReactor( logger log.Logger, - config *cfg.MempoolConfig, + cfg *config.MempoolConfig, peerMgr PeerManager, mp *CListMempool, mempoolCh *p2p.Channel, @@ -69,7 +69,7 @@ func NewReactor( ) *Reactor { r := &Reactor{ - config: config, + cfg: cfg, peerMgr: peerMgr, mempool: mp, ids: mempool.NewMempoolIDs(), @@ -90,8 +90,8 @@ func NewReactor( // // TODO: Remove once p2p refactor is complete. // ref: https://github.com/tendermint/tendermint/issues/5670 -func GetChannelShims(config *cfg.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDescriptorShim { - largestTx := make([]byte, config.MaxTxBytes) +func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDescriptorShim { + largestTx := make([]byte, cfg.MaxTxBytes) batchMsg := protomem.Message{ Sum: &protomem.Message_Txs{ Txs: &protomem.Txs{Txs: [][]byte{largestTx}}, @@ -117,7 +117,7 @@ func GetChannelShims(config *cfg.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe // messages on that p2p channel accordingly. The caller must be sure to execute // OnStop to ensure the outbound p2p Channels are closed. func (r *Reactor) OnStart() error { - if !r.config.Broadcast { + if !r.cfg.Broadcast { r.Logger.Info("tx broadcasting is disabled") } @@ -254,7 +254,7 @@ func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) { return } - if r.config.Broadcast { + if r.cfg.Broadcast { // Check if we've already started a goroutine for this peer, if not we create // a new done channel so we can explicitly close the goroutine if the peer // is later removed, we increment the waitgroup so the reactor can stop diff --git a/internal/mempool/v0/reactor_test.go b/internal/mempool/v0/reactor_test.go index 8bab45dd0..b0462a249 100644 --- a/internal/mempool/v0/reactor_test.go +++ b/internal/mempool/v0/reactor_test.go @@ -11,7 +11,7 @@ import ( 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/config" "github.com/tendermint/tendermint/internal/mempool" "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/internal/p2p/p2ptest" @@ -36,7 +36,7 @@ type reactorTestSuite struct { nodes []types.NodeID } -func setup(t *testing.T, cfg *cfg.MempoolConfig, numNodes int, chBuf uint) *reactorTestSuite { +func setup(t *testing.T, config *config.MempoolConfig, numNodes int, chBuf uint) *reactorTestSuite { t.Helper() rts := &reactorTestSuite{ @@ -68,7 +68,7 @@ func setup(t *testing.T, cfg *cfg.MempoolConfig, numNodes int, chBuf uint) *reac rts.reactors[nodeID] = NewReactor( rts.logger.With("nodeID", nodeID), - cfg, + config, rts.network.Nodes[nodeID].PeerManager, mempool, rts.mempoolChnnels[nodeID], @@ -158,9 +158,9 @@ func (rts *reactorTestSuite) waitForTxns(t *testing.T, txs types.Txs, ids ...typ func TestReactorBroadcastTxs(t *testing.T) { numTxs := 1000 numNodes := 10 - config := cfg.TestConfig() + cfg := config.TestConfig() - rts := setup(t, config.Mempool, numNodes, 0) + rts := setup(t, cfg.Mempool, numNodes, 0) primary := rts.nodes[0] secondaries := rts.nodes[1:] @@ -185,9 +185,9 @@ func TestReactorBroadcastTxs(t *testing.T) { func TestReactorConcurrency(t *testing.T) { numTxs := 5 numNodes := 2 - config := cfg.TestConfig() + cfg := config.TestConfig() - rts := setup(t, config.Mempool, numNodes, 0) + rts := setup(t, cfg.Mempool, numNodes, 0) primary := rts.nodes[0] secondary := rts.nodes[1] @@ -244,9 +244,9 @@ func TestReactorConcurrency(t *testing.T) { func TestReactorNoBroadcastToSender(t *testing.T) { numTxs := 1000 numNodes := 2 - config := cfg.TestConfig() + cfg := config.TestConfig() - rts := setup(t, config.Mempool, numNodes, uint(numTxs)) + rts := setup(t, cfg.Mempool, numNodes, uint(numTxs)) primary := rts.nodes[0] secondary := rts.nodes[1] @@ -267,16 +267,16 @@ func TestReactorNoBroadcastToSender(t *testing.T) { func TestReactor_MaxTxBytes(t *testing.T) { numNodes := 2 - config := cfg.TestConfig() + cfg := config.TestConfig() - rts := setup(t, config.Mempool, numNodes, 0) + rts := setup(t, cfg.Mempool, numNodes, 0) primary := rts.nodes[0] secondary := rts.nodes[1] // Broadcast a tx, which has the max size and ensure it's received by the // second reactor. - tx1 := tmrand.Bytes(config.Mempool.MaxTxBytes) + tx1 := tmrand.Bytes(cfg.Mempool.MaxTxBytes) err := rts.reactors[primary].mempool.CheckTx( context.Background(), tx1, @@ -297,7 +297,7 @@ func TestReactor_MaxTxBytes(t *testing.T) { rts.reactors[secondary].mempool.Flush() // broadcast a tx, which is beyond the max size and ensure it's not sent - tx2 := tmrand.Bytes(config.Mempool.MaxTxBytes + 1) + tx2 := tmrand.Bytes(cfg.Mempool.MaxTxBytes + 1) err = rts.mempools[primary].CheckTx(context.Background(), tx2, nil, mempool.TxInfo{SenderID: mempool.UnknownPeerID}) require.Error(t, err) @@ -305,11 +305,11 @@ func TestReactor_MaxTxBytes(t *testing.T) { } func TestDontExhaustMaxActiveIDs(t *testing.T) { - config := cfg.TestConfig() + cfg := config.TestConfig() // we're creating a single node network, but not starting the // network. - rts := setup(t, config.Mempool, 1, mempool.MaxActiveIDs+1) + rts := setup(t, cfg.Mempool, 1, mempool.MaxActiveIDs+1) nodeID := rts.nodes[0] @@ -374,9 +374,9 @@ func TestBroadcastTxForPeerStopsWhenPeerStops(t *testing.T) { t.Skip("skipping test in short mode") } - config := cfg.TestConfig() + cfg := config.TestConfig() - rts := setup(t, config.Mempool, 2, 0) + rts := setup(t, cfg.Mempool, 2, 0) primary := rts.nodes[0] secondary := rts.nodes[1] diff --git a/internal/mempool/v1/reactor.go b/internal/mempool/v1/reactor.go index 3014e0519..75f89d07e 100644 --- a/internal/mempool/v1/reactor.go +++ b/internal/mempool/v1/reactor.go @@ -8,7 +8,7 @@ import ( "sync" "time" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/internal/libs/clist" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/internal/mempool" @@ -37,7 +37,7 @@ type PeerManager interface { type Reactor struct { service.BaseService - config *cfg.MempoolConfig + cfg *config.MempoolConfig mempool *TxMempool ids *mempool.MempoolIDs @@ -65,7 +65,7 @@ type Reactor struct { // NewReactor returns a reference to a new reactor. func NewReactor( logger log.Logger, - config *cfg.MempoolConfig, + cfg *config.MempoolConfig, peerMgr PeerManager, txmp *TxMempool, mempoolCh *p2p.Channel, @@ -73,7 +73,7 @@ func NewReactor( ) *Reactor { r := &Reactor{ - config: config, + cfg: cfg, peerMgr: peerMgr, mempool: txmp, ids: mempool.NewMempoolIDs(), @@ -97,8 +97,8 @@ func defaultObservePanic(r interface{}) {} // // TODO: Remove once p2p refactor is complete. // ref: https://github.com/tendermint/tendermint/issues/5670 -func GetChannelShims(config *cfg.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDescriptorShim { - largestTx := make([]byte, config.MaxTxBytes) +func GetChannelShims(cfg *config.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDescriptorShim { + largestTx := make([]byte, cfg.MaxTxBytes) batchMsg := protomem.Message{ Sum: &protomem.Message_Txs{ Txs: &protomem.Txs{Txs: [][]byte{largestTx}}, @@ -124,7 +124,7 @@ func GetChannelShims(config *cfg.MempoolConfig) map[p2p.ChannelID]*p2p.ChannelDe // messages on that p2p channel accordingly. The caller must be sure to execute // OnStop to ensure the outbound p2p Channels are closed. func (r *Reactor) OnStart() error { - if !r.config.Broadcast { + if !r.cfg.Broadcast { r.Logger.Info("tx broadcasting is disabled") } @@ -262,7 +262,7 @@ func (r *Reactor) processPeerUpdate(peerUpdate p2p.PeerUpdate) { return } - if r.config.Broadcast { + if r.cfg.Broadcast { // Check if we've already started a goroutine for this peer, if not we create // a new done channel so we can explicitly close the goroutine if the peer // is later removed, we increment the waitgroup so the reactor can stop diff --git a/internal/p2p/conn/evil_secret_connection_test.go b/internal/p2p/conn/evil_secret_connection_test.go index 6d8b7cbf7..05e88cd85 100644 --- a/internal/p2p/conn/evil_secret_connection_test.go +++ b/internal/p2p/conn/evil_secret_connection_test.go @@ -13,7 +13,7 @@ import ( "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/internal/libs/protoio" tmp2p "github.com/tendermint/tendermint/proto/tendermint/p2p" ) @@ -113,7 +113,7 @@ func (c *evilConn) Read(data []byte) (n int, err error) { case 1: signature := c.signChallenge() if !c.badAuthSignature { - pkpb, err := cryptoenc.PubKeyToProto(c.privKey.PubKey()) + pkpb, err := encoding.PubKeyToProto(c.privKey.PubKey()) if err != nil { panic(err) } diff --git a/internal/p2p/conn/secret_connection.go b/internal/p2p/conn/secret_connection.go index 2f0d269d6..35fac488a 100644 --- a/internal/p2p/conn/secret_connection.go +++ b/internal/p2p/conn/secret_connection.go @@ -23,7 +23,7 @@ import ( "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/internal/libs/protoio" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/libs/async" @@ -406,7 +406,7 @@ func shareAuthSignature(sc io.ReadWriter, pubKey crypto.PubKey, signature []byte // Send our info and receive theirs in tandem. var trs, _ = async.Parallel( func(_ int) (val interface{}, abort bool, err error) { - pbpk, err := cryptoenc.PubKeyToProto(pubKey) + pbpk, err := encoding.PubKeyToProto(pubKey) if err != nil { return nil, true, err } @@ -423,7 +423,7 @@ func shareAuthSignature(sc io.ReadWriter, pubKey crypto.PubKey, signature []byte return nil, true, err // abort } - pk, err := cryptoenc.PubKeyFromProto(pba.PubKey) + pk, err := encoding.PubKeyFromProto(pba.PubKey) if err != nil { return nil, true, err // abort } diff --git a/internal/p2p/peermanager_scoring_test.go b/internal/p2p/peermanager_scoring_test.go index 0825af948..edb5fc6fc 100644 --- a/internal/p2p/peermanager_scoring_test.go +++ b/internal/p2p/peermanager_scoring_test.go @@ -6,9 +6,10 @@ import ( "time" "github.com/stretchr/testify/require" + dbm "github.com/tendermint/tm-db" + "github.com/tendermint/tendermint/crypto/ed25519" "github.com/tendermint/tendermint/types" - dbm "github.com/tendermint/tm-db" ) func TestPeerScoring(t *testing.T) { diff --git a/internal/p2p/pex/reactor_test.go b/internal/p2p/pex/reactor_test.go index a5acb0d5e..63e479e6a 100644 --- a/internal/p2p/pex/reactor_test.go +++ b/internal/p2p/pex/reactor_test.go @@ -14,7 +14,7 @@ import ( "github.com/tendermint/tendermint/internal/p2p/p2ptest" "github.com/tendermint/tendermint/internal/p2p/pex" "github.com/tendermint/tendermint/libs/log" - proto "github.com/tendermint/tendermint/proto/tendermint/p2p" + p2pproto "github.com/tendermint/tendermint/proto/tendermint/p2p" "github.com/tendermint/tendermint/types" ) @@ -45,7 +45,7 @@ func TestReactorBasic(t *testing.T) { // assert that when a mock node sends a request it receives a response (and // the correct one) testNet.sendRequest(t, firstNode, secondNode, true) - testNet.listenForResponse(t, secondNode, firstNode, shortWait, []proto.PexAddressV2(nil)) + testNet.listenForResponse(t, secondNode, firstNode, shortWait, []p2pproto.PexAddressV2(nil)) } func TestReactorConnectFullNetwork(t *testing.T) { @@ -71,17 +71,17 @@ func TestReactorSendsRequestsTooOften(t *testing.T) { r.pexInCh <- p2p.Envelope{ From: badNode, - Message: &proto.PexRequestV2{}, + Message: &p2pproto.PexRequestV2{}, } resp := <-r.pexOutCh - msg, ok := resp.Message.(*proto.PexResponseV2) + msg, ok := resp.Message.(*p2pproto.PexResponseV2) require.True(t, ok) require.Empty(t, msg.Addresses) r.pexInCh <- p2p.Envelope{ From: badNode, - Message: &proto.PexRequestV2{}, + Message: &p2pproto.PexRequestV2{}, } peerErr := <-r.pexErrCh @@ -136,10 +136,10 @@ func TestReactorErrorsOnReceivingTooManyPeers(t *testing.T) { require.NoError(t, err) require.True(t, added) - addresses := make([]proto.PexAddressV2, 101) + addresses := make([]p2pproto.PexAddressV2, 101) for i := 0; i < len(addresses); i++ { nodeAddress := p2p.NodeAddress{Protocol: p2p.MemoryProtocol, NodeID: randomNodeID(t)} - addresses[i] = proto.PexAddressV2{ + addresses[i] = p2pproto.PexAddressV2{ URL: nodeAddress.String(), } } @@ -152,12 +152,12 @@ func TestReactorErrorsOnReceivingTooManyPeers(t *testing.T) { select { // wait for a request and then send a response with too many addresses case req := <-r.pexOutCh: - if _, ok := req.Message.(*proto.PexRequestV2); !ok { + if _, ok := req.Message.(*p2pproto.PexRequestV2); !ok { t.Fatal("expected v2 pex request") } r.pexInCh <- p2p.Envelope{ From: peer.NodeID, - Message: &proto.PexResponseV2{ + Message: &p2pproto.PexResponseV2{ Addresses: addresses, }, } @@ -290,7 +290,7 @@ func setupSingle(t *testing.T) *singleTestReactor { pexErrCh := make(chan p2p.PeerError, chBuf) pexCh := p2p.NewChannel( p2p.ChannelID(pex.PexChannel), - new(proto.PexMessage), + new(p2pproto.PexMessage), pexInCh, pexOutCh, pexErrCh, @@ -381,7 +381,7 @@ func setupNetwork(t *testing.T, opts testOptions) *reactorTestSuite { // NOTE: we don't assert that the channels get drained after stopping the // reactor rts.pexChannels = rts.network.MakeChannelsNoCleanup( - t, pex.ChannelDescriptor(), new(proto.PexMessage), chBuf, + t, pex.ChannelDescriptor(), new(p2pproto.PexMessage), chBuf, ) idx := 0 @@ -447,7 +447,7 @@ func (r *reactorTestSuite) addNodes(t *testing.T, nodes int) { r.network.Nodes[node.NodeID] = node nodeID := node.NodeID r.pexChannels[nodeID] = node.MakeChannelNoCleanup( - t, pex.ChannelDescriptor(), new(proto.PexMessage), r.opts.BufferSize, + t, pex.ChannelDescriptor(), new(p2pproto.PexMessage), r.opts.BufferSize, ) r.peerChans[nodeID] = make(chan p2p.PeerUpdate, r.opts.BufferSize) r.peerUpdates[nodeID] = p2p.NewPeerUpdates(r.peerChans[nodeID], r.opts.BufferSize) @@ -488,11 +488,11 @@ func (r *reactorTestSuite) listenForRequest(t *testing.T, fromNode, toNode int, r.logger.Info("Listening for request", "from", fromNode, "to", toNode) to, from := r.checkNodePair(t, toNode, fromNode) conditional := func(msg p2p.Envelope) bool { - _, ok := msg.Message.(*proto.PexRequestV2) + _, ok := msg.Message.(*p2pproto.PexRequestV2) return ok && msg.From == from } assertion := func(t *testing.T, msg p2p.Envelope) bool { - require.Equal(t, &proto.PexRequestV2{}, msg.Message) + require.Equal(t, &p2pproto.PexRequestV2{}, msg.Message) return true } r.listenFor(t, to, conditional, assertion, waitPeriod) @@ -507,11 +507,11 @@ func (r *reactorTestSuite) pingAndlistenForNAddresses( r.logger.Info("Listening for addresses", "from", fromNode, "to", toNode) to, from := r.checkNodePair(t, toNode, fromNode) conditional := func(msg p2p.Envelope) bool { - _, ok := msg.Message.(*proto.PexResponseV2) + _, ok := msg.Message.(*p2pproto.PexResponseV2) return ok && msg.From == from } assertion := func(t *testing.T, msg p2p.Envelope) bool { - m, ok := msg.Message.(*proto.PexResponseV2) + m, ok := msg.Message.(*p2pproto.PexResponseV2) if !ok { require.Fail(t, "expected pex response v2") return true @@ -534,17 +534,17 @@ func (r *reactorTestSuite) listenForResponse( t *testing.T, fromNode, toNode int, waitPeriod time.Duration, - addresses []proto.PexAddressV2, + addresses []p2pproto.PexAddressV2, ) { r.logger.Info("Listening for response", "from", fromNode, "to", toNode) to, from := r.checkNodePair(t, toNode, fromNode) conditional := func(msg p2p.Envelope) bool { - _, ok := msg.Message.(*proto.PexResponseV2) + _, ok := msg.Message.(*p2pproto.PexResponseV2) r.logger.Info("message", msg, "ok", ok) return ok && msg.From == from } assertion := func(t *testing.T, msg p2p.Envelope) bool { - require.Equal(t, &proto.PexResponseV2{Addresses: addresses}, msg.Message) + require.Equal(t, &p2pproto.PexResponseV2{Addresses: addresses}, msg.Message) return true } r.listenFor(t, to, conditional, assertion, waitPeriod) @@ -554,16 +554,16 @@ func (r *reactorTestSuite) listenForLegacyResponse( t *testing.T, fromNode, toNode int, waitPeriod time.Duration, - addresses []proto.PexAddress, + addresses []p2pproto.PexAddress, ) { r.logger.Info("Listening for response", "from", fromNode, "to", toNode) to, from := r.checkNodePair(t, toNode, fromNode) conditional := func(msg p2p.Envelope) bool { - _, ok := msg.Message.(*proto.PexResponse) + _, ok := msg.Message.(*p2pproto.PexResponse) return ok && msg.From == from } assertion := func(t *testing.T, msg p2p.Envelope) bool { - require.Equal(t, &proto.PexResponse{Addresses: addresses}, msg.Message) + require.Equal(t, &p2pproto.PexResponse{Addresses: addresses}, msg.Message) return true } r.listenFor(t, to, conditional, assertion, waitPeriod) @@ -595,26 +595,26 @@ func (r *reactorTestSuite) listenForPeerUpdate( } } -func (r *reactorTestSuite) getV2AddressesFor(nodes []int) []proto.PexAddressV2 { - addresses := make([]proto.PexAddressV2, len(nodes)) +func (r *reactorTestSuite) getV2AddressesFor(nodes []int) []p2pproto.PexAddressV2 { + addresses := make([]p2pproto.PexAddressV2, len(nodes)) for idx, node := range nodes { nodeID := r.nodes[node] - addresses[idx] = proto.PexAddressV2{ + addresses[idx] = p2pproto.PexAddressV2{ URL: r.network.Nodes[nodeID].NodeAddress.String(), } } return addresses } -func (r *reactorTestSuite) getAddressesFor(t *testing.T, nodes []int) []proto.PexAddress { - addresses := make([]proto.PexAddress, len(nodes)) +func (r *reactorTestSuite) getAddressesFor(t *testing.T, nodes []int) []p2pproto.PexAddress { + addresses := make([]p2pproto.PexAddress, len(nodes)) for idx, node := range nodes { nodeID := r.nodes[node] nodeAddrs := r.network.Nodes[nodeID].NodeAddress endpoints, err := nodeAddrs.Resolve(context.Background()) require.NoError(t, err) require.Len(t, endpoints, 1) - addresses[idx] = proto.PexAddress{ + addresses[idx] = p2pproto.PexAddress{ ID: string(nodeAddrs.NodeID), IP: endpoints[0].IP.String(), Port: uint32(endpoints[0].Port), @@ -628,12 +628,12 @@ func (r *reactorTestSuite) sendRequest(t *testing.T, fromNode, toNode int, v2 bo if v2 { r.pexChannels[from].Out <- p2p.Envelope{ To: to, - Message: &proto.PexRequestV2{}, + Message: &p2pproto.PexRequestV2{}, } } else { r.pexChannels[from].Out <- p2p.Envelope{ To: to, - Message: &proto.PexRequest{}, + Message: &p2pproto.PexRequest{}, } } } @@ -649,7 +649,7 @@ func (r *reactorTestSuite) sendResponse( addrs := r.getV2AddressesFor(withNodes) r.pexChannels[from].Out <- p2p.Envelope{ To: to, - Message: &proto.PexResponseV2{ + Message: &p2pproto.PexResponseV2{ Addresses: addrs, }, } @@ -657,7 +657,7 @@ func (r *reactorTestSuite) sendResponse( addrs := r.getAddressesFor(t, withNodes) r.pexChannels[from].Out <- p2p.Envelope{ To: to, - Message: &proto.PexResponse{ + Message: &p2pproto.PexResponse{ Addresses: addrs, }, } @@ -764,8 +764,8 @@ func (r *reactorTestSuite) connectPeers(t *testing.T, sourceNode, targetNode int } // nolint: unused -func (r *reactorTestSuite) pexAddresses(t *testing.T, nodeIndices []int) []proto.PexAddress { - var addresses []proto.PexAddress +func (r *reactorTestSuite) pexAddresses(t *testing.T, nodeIndices []int) []p2pproto.PexAddress { + var addresses []p2pproto.PexAddress for _, i := range nodeIndices { if i < len(r.nodes) { require.Fail(t, "index for pex address is greater than number of nodes") @@ -777,7 +777,7 @@ func (r *reactorTestSuite) pexAddresses(t *testing.T, nodeIndices []int) []proto require.NoError(t, err) for _, endpoint := range endpoints { if endpoint.IP != nil { - addresses = append(addresses, proto.PexAddress{ + addresses = append(addresses, p2pproto.PexAddress{ ID: string(nodeAddrs.NodeID), IP: endpoint.IP.String(), Port: uint32(endpoint.Port), diff --git a/internal/rpc/core/abci.go b/internal/rpc/core/abci.go index fe497b336..06c033050 100644 --- a/internal/rpc/core/abci.go +++ b/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 } diff --git a/internal/rpc/core/blocks.go b/internal/rpc/core/blocks.go index 909d2228f..26472fab4 100644 --- a/internal/rpc/core/blocks.go +++ b/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 } diff --git a/internal/rpc/core/blocks_test.go b/internal/rpc/core/blocks_test.go index 5b602e339..68237bc0b 100644 --- a/internal/rpc/core/blocks_test.go +++ b/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, diff --git a/internal/rpc/core/consensus.go b/internal/rpc/core/consensus.go index 6fbba0c0f..ac49bbd31 100644 --- a/internal/rpc/core/consensus.go +++ b/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 } diff --git a/internal/rpc/core/dev.go b/internal/rpc/core/dev.go index fde7aef99..21c5154ff 100644 --- a/internal/rpc/core/dev.go +++ b/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 } diff --git a/internal/rpc/core/env.go b/internal/rpc/core/env.go index 44264e949..11b138eac 100644 --- a/internal/rpc/core/env.go +++ b/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 } diff --git a/internal/rpc/core/events.go b/internal/rpc/core/events.go index d26a4d90f..8632e00c1 100644 --- a/internal/rpc/core/events.go +++ b/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 } diff --git a/internal/rpc/core/evidence.go b/internal/rpc/core/evidence.go index 311180bdd..a7641b99d 100644 --- a/internal/rpc/core/evidence.go +++ b/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 } diff --git a/internal/rpc/core/health.go b/internal/rpc/core/health.go index fa92d57ab..fc355c7e7 100644 --- a/internal/rpc/core/health.go +++ b/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 } diff --git a/internal/rpc/core/mempool.go b/internal/rpc/core/mempool.go index b44b9fb33..d66cabadd 100644 --- a/internal/rpc/core/mempool.go +++ b/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 } diff --git a/internal/rpc/core/net.go b/internal/rpc/core/net.go index 633359449..8bcc04dd0 100644 --- a/internal/rpc/core/net.go +++ b/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], diff --git a/internal/rpc/core/net_test.go b/internal/rpc/core/net_test.go index 821cdb663..7c12a69d6 100644 --- a/internal/rpc/core/net_test.go +++ b/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{}), diff --git a/internal/rpc/core/status.go b/internal/rpc/core/status.go index 567d73be4..bdd7ee1fa 100644 --- a/internal/rpc/core/status.go +++ b/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, diff --git a/internal/rpc/core/tx.go b/internal/rpc/core/tx.go index 75a537942..60c7519c0 100644 --- a/internal/rpc/core/tx.go +++ b/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 } } diff --git a/internal/state/execution.go b/internal/state/execution.go index f5380de7c..e3dc80dca 100644 --- a/internal/state/execution.go +++ b/internal/state/execution.go @@ -7,9 +7,9 @@ import ( "time" abci "github.com/tendermint/tendermint/abci/types" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "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/mempool" "github.com/tendermint/tendermint/internal/proxy" "github.com/tendermint/tendermint/libs/log" tmstate "github.com/tendermint/tendermint/proto/tendermint/state" @@ -37,7 +37,7 @@ type BlockExecutor struct { // manage the mempool lock during commit // and update both with block results after commit. - mempool mempl.Mempool + mempool mempool.Mempool evpool EvidencePool logger log.Logger @@ -61,7 +61,7 @@ func NewBlockExecutor( stateStore Store, logger log.Logger, proxyApp proxy.AppConnConsensus, - mempool mempl.Mempool, + pool mempool.Mempool, evpool EvidencePool, blockStore BlockStore, options ...BlockExecutorOption, @@ -70,7 +70,7 @@ func NewBlockExecutor( store: stateStore, proxyApp: proxyApp, eventBus: types.NopEventBus{}, - mempool: mempool, + mempool: pool, evpool: evpool, logger: logger, metrics: NopMetrics(), @@ -424,7 +424,7 @@ func validateValidatorUpdates(abciUpdates []abci.ValidatorUpdate, } // Check if validator's pubkey matches an ABCI type in the consensus params - pk, err := cryptoenc.PubKeyFromProto(valUpdate.PubKey) + pk, err := encoding.PubKeyFromProto(valUpdate.PubKey) if err != nil { return err } diff --git a/internal/state/execution_test.go b/internal/state/execution_test.go index 69085694b..d777d1699 100644 --- a/internal/state/execution_test.go +++ b/internal/state/execution_test.go @@ -8,12 +8,13 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + dbm "github.com/tendermint/tm-db" abciclient "github.com/tendermint/tendermint/abci/client" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "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" @@ -25,7 +26,6 @@ import ( "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" "github.com/tendermint/tendermint/version" - dbm "github.com/tendermint/tm-db" ) var ( @@ -218,9 +218,9 @@ func TestBeginBlockByzantineValidators(t *testing.T) { func TestValidateValidatorUpdates(t *testing.T) { pubkey1 := ed25519.GenPrivKey().PubKey() pubkey2 := ed25519.GenPrivKey().PubKey() - pk1, err := cryptoenc.PubKeyToProto(pubkey1) + pk1, err := encoding.PubKeyToProto(pubkey1) assert.NoError(t, err) - pk2, err := cryptoenc.PubKeyToProto(pubkey2) + pk2, err := encoding.PubKeyToProto(pubkey2) assert.NoError(t, err) defaultValidatorParams := types.ValidatorParams{PubKeyTypes: []string{types.ABCIPubKeyTypeEd25519}} @@ -278,9 +278,9 @@ func TestUpdateValidators(t *testing.T) { pubkey2 := ed25519.GenPrivKey().PubKey() val2 := types.NewValidator(pubkey2, 20) - pk, err := cryptoenc.PubKeyToProto(pubkey1) + pk, err := encoding.PubKeyToProto(pubkey1) require.NoError(t, err) - pk2, err := cryptoenc.PubKeyToProto(pubkey2) + pk2, err := encoding.PubKeyToProto(pubkey2) require.NoError(t, err) testCases := []struct { @@ -385,7 +385,7 @@ func TestEndBlockValidatorUpdates(t *testing.T) { blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} pubkey := ed25519.GenPrivKey().PubKey() - pk, err := cryptoenc.PubKeyToProto(pubkey) + pk, err := encoding.PubKeyToProto(pubkey) require.NoError(t, err) app.ValidatorUpdates = []abci.ValidatorUpdate{ {PubKey: pk, Power: 10}, @@ -442,7 +442,7 @@ func TestEndBlockValidatorUpdatesResultingInEmptySet(t *testing.T) { block := sf.MakeBlock(state, 1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} - vp, err := cryptoenc.PubKeyToProto(state.Validators.Validators[0].PubKey) + vp, err := encoding.PubKeyToProto(state.Validators.Validators[0].PubKey) require.NoError(t, err) // Remove the only validator app.ValidatorUpdates = []abci.ValidatorUpdate{ diff --git a/internal/state/helpers_test.go b/internal/state/helpers_test.go index f20475633..f8ed77b32 100644 --- a/internal/state/helpers_test.go +++ b/internal/state/helpers_test.go @@ -11,7 +11,7 @@ import ( 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/encoding" "github.com/tendermint/tendermint/internal/proxy" sm "github.com/tendermint/tendermint/internal/state" sf "github.com/tendermint/tendermint/internal/state/test/factory" @@ -148,11 +148,11 @@ func makeHeaderPartsResponsesValPubKeyChange( // If the pubkey is new, remove the old and add the new. _, val := state.NextValidators.GetByIndex(0) if !bytes.Equal(pubkey.Bytes(), val.PubKey.Bytes()) { - vPbPk, err := cryptoenc.PubKeyToProto(val.PubKey) + vPbPk, err := encoding.PubKeyToProto(val.PubKey) if err != nil { panic(err) } - pbPk, err := cryptoenc.PubKeyToProto(pubkey) + pbPk, err := encoding.PubKeyToProto(pubkey) if err != nil { panic(err) } @@ -181,7 +181,7 @@ func makeHeaderPartsResponsesValPowerChange( // If the pubkey is new, remove the old and add the new. _, val := state.NextValidators.GetByIndex(0) if val.VotingPower != power { - vPbPk, err := cryptoenc.PubKeyToProto(val.PubKey) + vPbPk, err := encoding.PubKeyToProto(val.PubKey) if err != nil { panic(err) } diff --git a/internal/state/indexer/block/kv/kv_test.go b/internal/state/indexer/block/kv/kv_test.go index 2601c878b..024df332c 100644 --- a/internal/state/indexer/block/kv/kv_test.go +++ b/internal/state/indexer/block/kv/kv_test.go @@ -6,15 +6,16 @@ import ( "testing" "github.com/stretchr/testify/require" + dbm "github.com/tendermint/tm-db" + abci "github.com/tendermint/tendermint/abci/types" blockidxkv "github.com/tendermint/tendermint/internal/state/indexer/block/kv" "github.com/tendermint/tendermint/libs/pubsub/query" "github.com/tendermint/tendermint/types" - db "github.com/tendermint/tm-db" ) func TestBlockIndexer(t *testing.T) { - store := db.NewPrefixDB(db.NewMemDB(), []byte("block_events")) + store := dbm.NewPrefixDB(dbm.NewMemDB(), []byte("block_events")) indexer := blockidxkv.New(store) require.NoError(t, indexer.Index(types.EventDataNewBlockHeader{ diff --git a/internal/state/indexer/indexer_service_test.go b/internal/state/indexer/indexer_service_test.go index e630b07e9..d9f29b677 100644 --- a/internal/state/indexer/indexer_service_test.go +++ b/internal/state/indexer/indexer_service_test.go @@ -9,11 +9,11 @@ import ( "time" "github.com/adlio/schema" - _ "github.com/lib/pq" dockertest "github.com/ory/dockertest" "github.com/ory/dockertest/docker" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + dbm "github.com/tendermint/tm-db" abci "github.com/tendermint/tendermint/abci/types" indexer "github.com/tendermint/tendermint/internal/state/indexer" @@ -21,7 +21,9 @@ import ( psql "github.com/tendermint/tendermint/internal/state/indexer/sink/psql" tmlog "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/types" - db "github.com/tendermint/tm-db" + + // Register the Postgre database driver. + _ "github.com/lib/pq" ) var psqldb *sql.DB @@ -55,7 +57,7 @@ func TestIndexerServiceIndexesBlocks(t *testing.T) { pool, err := setupDB(t) assert.Nil(t, err) - store := db.NewMemDB() + store := dbm.NewMemDB() eventSinks := []indexer.EventSink{kv.NewEventSink(store), pSink} assert.True(t, indexer.KVSinkEnabled(eventSinks)) assert.True(t, indexer.IndexingEnabled(eventSinks)) diff --git a/internal/state/indexer/sink/kv/kv.go b/internal/state/indexer/sink/kv/kv.go index eda8da846..4c471b4d3 100644 --- a/internal/state/indexer/sink/kv/kv.go +++ b/internal/state/indexer/sink/kv/kv.go @@ -3,13 +3,14 @@ package kv import ( "context" + dbm "github.com/tendermint/tm-db" + abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/internal/state/indexer" kvb "github.com/tendermint/tendermint/internal/state/indexer/block/kv" kvt "github.com/tendermint/tendermint/internal/state/indexer/tx/kv" "github.com/tendermint/tendermint/libs/pubsub/query" "github.com/tendermint/tendermint/types" - dbm "github.com/tendermint/tm-db" ) var _ indexer.EventSink = (*EventSink)(nil) diff --git a/internal/state/indexer/sink/kv/kv_test.go b/internal/state/indexer/sink/kv/kv_test.go index d59f4ea90..7d7552946 100644 --- a/internal/state/indexer/sink/kv/kv_test.go +++ b/internal/state/indexer/sink/kv/kv_test.go @@ -5,6 +5,8 @@ import ( "fmt" "testing" + dbm "github.com/tendermint/tm-db" + "github.com/gogo/protobuf/proto" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -13,21 +15,20 @@ import ( kvtx "github.com/tendermint/tendermint/internal/state/indexer/tx/kv" "github.com/tendermint/tendermint/libs/pubsub/query" "github.com/tendermint/tendermint/types" - db "github.com/tendermint/tm-db" ) func TestType(t *testing.T) { - kvSink := NewEventSink(db.NewMemDB()) + kvSink := NewEventSink(dbm.NewMemDB()) assert.Equal(t, indexer.KV, kvSink.Type()) } func TestStop(t *testing.T) { - kvSink := NewEventSink(db.NewMemDB()) + kvSink := NewEventSink(dbm.NewMemDB()) assert.Nil(t, kvSink.Stop()) } func TestBlockFuncs(t *testing.T) { - store := db.NewPrefixDB(db.NewMemDB(), []byte("block_events")) + store := dbm.NewPrefixDB(dbm.NewMemDB(), []byte("block_events")) indexer := NewEventSink(store) require.NoError(t, indexer.IndexBlockEvents(types.EventDataNewBlockHeader{ @@ -158,7 +159,7 @@ func TestBlockFuncs(t *testing.T) { } func TestTxSearchWithCancelation(t *testing.T) { - indexer := NewEventSink(db.NewMemDB()) + indexer := NewEventSink(dbm.NewMemDB()) txResult := txResultWithEvents([]abci.Event{ {Type: "account", Attributes: []abci.EventAttribute{{Key: "number", Value: "1", Index: true}}}, @@ -180,7 +181,7 @@ func TestTxSearchWithCancelation(t *testing.T) { } func TestTxSearchDeprecatedIndexing(t *testing.T) { - esdb := db.NewMemDB() + esdb := dbm.NewMemDB() indexer := NewEventSink(esdb) // index tx using events indexing (composite key) @@ -260,7 +261,7 @@ func TestTxSearchDeprecatedIndexing(t *testing.T) { } func TestTxSearchOneTxWithMultipleSameTagsButDifferentValues(t *testing.T) { - indexer := NewEventSink(db.NewMemDB()) + indexer := NewEventSink(dbm.NewMemDB()) txResult := txResultWithEvents([]abci.Event{ {Type: "account", Attributes: []abci.EventAttribute{{Key: "number", Value: "1", Index: true}}}, @@ -282,7 +283,7 @@ func TestTxSearchOneTxWithMultipleSameTagsButDifferentValues(t *testing.T) { } func TestTxSearchMultipleTxs(t *testing.T) { - indexer := NewEventSink(db.NewMemDB()) + indexer := NewEventSink(dbm.NewMemDB()) // indexed first, but bigger height (to test the order of transactions) txResult := txResultWithEvents([]abci.Event{ diff --git a/internal/state/indexer/tx/kv/kv_test.go b/internal/state/indexer/tx/kv/kv_test.go index 064421f5f..c8ab2b0f2 100644 --- a/internal/state/indexer/tx/kv/kv_test.go +++ b/internal/state/indexer/tx/kv/kv_test.go @@ -10,8 +10,7 @@ import ( "github.com/gogo/protobuf/proto" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - - db "github.com/tendermint/tm-db" + dbm "github.com/tendermint/tm-db" abci "github.com/tendermint/tendermint/abci/types" indexer "github.com/tendermint/tendermint/internal/state/indexer" @@ -21,7 +20,7 @@ import ( ) func TestTxIndex(t *testing.T) { - txIndexer := NewTxIndex(db.NewMemDB()) + txIndexer := NewTxIndex(dbm.NewMemDB()) tx := types.Tx("HELLO WORLD") txResult := &abci.TxResult{ @@ -67,7 +66,7 @@ func TestTxIndex(t *testing.T) { } func TestTxSearch(t *testing.T) { - indexer := NewTxIndex(db.NewMemDB()) + indexer := NewTxIndex(dbm.NewMemDB()) txResult := txResultWithEvents([]abci.Event{ {Type: "account", Attributes: []abci.EventAttribute{{Key: "number", Value: "1", Index: true}}}, @@ -147,7 +146,7 @@ func TestTxSearch(t *testing.T) { } func TestTxSearchWithCancelation(t *testing.T) { - indexer := NewTxIndex(db.NewMemDB()) + indexer := NewTxIndex(dbm.NewMemDB()) txResult := txResultWithEvents([]abci.Event{ {Type: "account", Attributes: []abci.EventAttribute{{Key: "number", Value: "1", Index: true}}}, @@ -165,7 +164,7 @@ func TestTxSearchWithCancelation(t *testing.T) { } func TestTxSearchDeprecatedIndexing(t *testing.T) { - indexer := NewTxIndex(db.NewMemDB()) + indexer := NewTxIndex(dbm.NewMemDB()) // index tx using events indexing (composite key) txResult1 := txResultWithEvents([]abci.Event{ @@ -244,7 +243,7 @@ func TestTxSearchDeprecatedIndexing(t *testing.T) { } func TestTxSearchOneTxWithMultipleSameTagsButDifferentValues(t *testing.T) { - indexer := NewTxIndex(db.NewMemDB()) + indexer := NewTxIndex(dbm.NewMemDB()) txResult := txResultWithEvents([]abci.Event{ {Type: "account", Attributes: []abci.EventAttribute{{Key: "number", Value: "1", Index: true}}}, @@ -266,7 +265,7 @@ func TestTxSearchOneTxWithMultipleSameTagsButDifferentValues(t *testing.T) { } func TestTxSearchMultipleTxs(t *testing.T) { - indexer := NewTxIndex(db.NewMemDB()) + indexer := NewTxIndex(dbm.NewMemDB()) // indexed first, but bigger height (to test the order of transactions) txResult := txResultWithEvents([]abci.Event{ @@ -339,7 +338,7 @@ func benchmarkTxIndex(txsCount int64, b *testing.B) { require.NoError(b, err) defer os.RemoveAll(dir) - store, err := db.NewDB("tx_index", "goleveldb", dir) + store, err := dbm.NewDB("tx_index", "goleveldb", dir) require.NoError(b, err) txIndexer := NewTxIndex(store) diff --git a/internal/state/state_test.go b/internal/state/state_test.go index 102b206c2..ab73bc90c 100644 --- a/internal/state/state_test.go +++ b/internal/state/state_test.go @@ -12,36 +12,35 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - dbm "github.com/tendermint/tm-db" abci "github.com/tendermint/tendermint/abci/types" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" sm "github.com/tendermint/tendermint/internal/state" - sf "github.com/tendermint/tendermint/internal/state/test/factory" + statefactory "github.com/tendermint/tendermint/internal/state/test/factory" tmstate "github.com/tendermint/tendermint/proto/tendermint/state" "github.com/tendermint/tendermint/types" ) // setupTestCase does setup common to all test cases. func setupTestCase(t *testing.T) (func(t *testing.T), dbm.DB, sm.State) { - config := cfg.ResetTestRoot("state_") - dbType := dbm.BackendType(config.DBBackend) - stateDB, err := dbm.NewDB("state", dbType, config.DBDir()) + cfg := config.ResetTestRoot("state_") + dbType := dbm.BackendType(cfg.DBBackend) + stateDB, err := dbm.NewDB("state", dbType, cfg.DBDir()) require.NoError(t, err) stateStore := sm.NewStore(stateDB) state, err := stateStore.Load() require.NoError(t, err) require.Empty(t, state) - state, err = sm.MakeGenesisStateFromFile(config.GenesisFile()) + state, err = sm.MakeGenesisStateFromFile(cfg.GenesisFile()) assert.NoError(t, err) assert.NotNil(t, state) err = stateStore.Save(state) require.NoError(t, err) - tearDown := func(t *testing.T) { os.RemoveAll(config.RootDir) } + tearDown := func(t *testing.T) { os.RemoveAll(cfg.RootDir) } return tearDown, stateDB, state } @@ -106,7 +105,7 @@ func TestABCIResponsesSaveLoad1(t *testing.T) { state.LastBlockHeight++ // Build mock responses. - block := sf.MakeBlock(state, 2, new(types.Commit)) + block := statefactory.MakeBlock(state, 2, new(types.Commit)) abciResponses := new(tmstate.ABCIResponses) dtxs := make([]*abci.ResponseDeliverTx, 2) @@ -114,7 +113,7 @@ func TestABCIResponsesSaveLoad1(t *testing.T) { abciResponses.DeliverTxs[0] = &abci.ResponseDeliverTx{Data: []byte("foo"), Events: nil} abciResponses.DeliverTxs[1] = &abci.ResponseDeliverTx{Data: []byte("bar"), Log: "ok", Events: nil} - pbpk, err := cryptoenc.PubKeyToProto(ed25519.GenPrivKey().PubKey()) + pbpk, err := encoding.PubKeyToProto(ed25519.GenPrivKey().PubKey()) require.NoError(t, err) abciResponses.EndBlock = &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{{PubKey: pbpk, Power: 10}}} @@ -448,7 +447,7 @@ func TestProposerPriorityDoesNotGetResetToZero(t *testing.T) { // NewValidatorSet calls IncrementProposerPriority but uses on a copy of val1 assert.EqualValues(t, 0, val1.ProposerPriority) - block := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + block := statefactory.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} abciResponses := &tmstate.ABCIResponses{ BeginBlock: &abci.ResponseBeginBlock{}, @@ -465,7 +464,7 @@ func TestProposerPriorityDoesNotGetResetToZero(t *testing.T) { // add a validator val2PubKey := ed25519.GenPrivKey().PubKey() val2VotingPower := int64(100) - fvp, err := cryptoenc.PubKeyToProto(val2PubKey) + fvp, err := encoding.PubKeyToProto(val2PubKey) require.NoError(t, err) updateAddVal := abci.ValidatorUpdate{PubKey: fvp, Power: val2VotingPower} @@ -562,7 +561,7 @@ func TestProposerPriorityProposerAlternates(t *testing.T) { // we only have one validator: assert.Equal(t, val1PubKey.Address(), state.Validators.Proposer.Address) - block := sf.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) + block := statefactory.MakeBlock(state, state.LastBlockHeight+1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} // no updates: abciResponses := &tmstate.ABCIResponses{ @@ -583,7 +582,7 @@ func TestProposerPriorityProposerAlternates(t *testing.T) { // add a validator with the same voting power as the first val2PubKey := ed25519.GenPrivKey().PubKey() - fvp, err := cryptoenc.PubKeyToProto(val2PubKey) + fvp, err := encoding.PubKeyToProto(val2PubKey) require.NoError(t, err) updateAddVal := abci.ValidatorUpdate{PubKey: fvp, Power: val1VotingPower} validatorUpdates, err = types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{updateAddVal}) @@ -749,7 +748,7 @@ func TestLargeGenesisValidator(t *testing.T) { validatorUpdates, err := types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block := sf.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + block := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates) @@ -769,7 +768,7 @@ func TestLargeGenesisValidator(t *testing.T) { // see: https://github.com/tendermint/tendermint/issues/2960 firstAddedValPubKey := ed25519.GenPrivKey().PubKey() firstAddedValVotingPower := int64(10) - fvp, err := cryptoenc.PubKeyToProto(firstAddedValPubKey) + fvp, err := encoding.PubKeyToProto(firstAddedValPubKey) require.NoError(t, err) firstAddedVal := abci.ValidatorUpdate{PubKey: fvp, Power: firstAddedValVotingPower} validatorUpdates, err := types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{firstAddedVal}) @@ -778,7 +777,7 @@ func TestLargeGenesisValidator(t *testing.T) { BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{firstAddedVal}}, } - block := sf.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + block := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} updatedState, err := sm.UpdateState(oldState, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) @@ -793,7 +792,7 @@ func TestLargeGenesisValidator(t *testing.T) { validatorUpdates, err := types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block := sf.MakeBlock(lastState, lastState.LastBlockHeight+1, new(types.Commit)) + block := statefactory.MakeBlock(lastState, lastState.LastBlockHeight+1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} updatedStateInner, err := sm.UpdateState(lastState, blockID, &block.Header, abciResponses, validatorUpdates) @@ -816,7 +815,7 @@ func TestLargeGenesisValidator(t *testing.T) { // add 10 validators with the same voting power as the one added directly after genesis: for i := 0; i < 10; i++ { addedPubKey := ed25519.GenPrivKey().PubKey() - ap, err := cryptoenc.PubKeyToProto(addedPubKey) + ap, err := encoding.PubKeyToProto(addedPubKey) require.NoError(t, err) addedVal := abci.ValidatorUpdate{PubKey: ap, Power: firstAddedValVotingPower} validatorUpdates, err := types.PB2TM.ValidatorUpdates([]abci.ValidatorUpdate{addedVal}) @@ -826,7 +825,7 @@ func TestLargeGenesisValidator(t *testing.T) { BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{addedVal}}, } - block := sf.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + block := statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} state, err = sm.UpdateState(state, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) @@ -834,14 +833,14 @@ func TestLargeGenesisValidator(t *testing.T) { require.Equal(t, 10+2, len(state.NextValidators.Validators)) // remove genesis validator: - gp, err := cryptoenc.PubKeyToProto(genesisPubKey) + gp, err := encoding.PubKeyToProto(genesisPubKey) require.NoError(t, err) removeGenesisVal := abci.ValidatorUpdate{PubKey: gp, Power: 0} abciResponses = &tmstate.ABCIResponses{ BeginBlock: &abci.ResponseBeginBlock{}, EndBlock: &abci.ResponseEndBlock{ValidatorUpdates: []abci.ValidatorUpdate{removeGenesisVal}}, } - block = sf.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) + block = statefactory.MakeBlock(oldState, oldState.LastBlockHeight+1, new(types.Commit)) blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) @@ -862,7 +861,7 @@ func TestLargeGenesisValidator(t *testing.T) { } validatorUpdates, err = types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block = sf.MakeBlock(curState, curState.LastBlockHeight+1, new(types.Commit)) + block = statefactory.MakeBlock(curState, curState.LastBlockHeight+1, new(types.Commit)) blockID = types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} curState, err = sm.UpdateState(curState, blockID, &block.Header, abciResponses, validatorUpdates) require.NoError(t, err) @@ -887,7 +886,7 @@ func TestLargeGenesisValidator(t *testing.T) { validatorUpdates, err := types.PB2TM.ValidatorUpdates(abciResponses.EndBlock.ValidatorUpdates) require.NoError(t, err) - block := sf.MakeBlock(updatedState, updatedState.LastBlockHeight+1, new(types.Commit)) + block := statefactory.MakeBlock(updatedState, updatedState.LastBlockHeight+1, new(types.Commit)) blockID := types.BlockID{Hash: block.Hash(), PartSetHeader: block.MakePartSet(testPartSize).Header()} updatedState, err = sm.UpdateState(updatedState, blockID, &block.Header, abciResponses, validatorUpdates) @@ -982,7 +981,7 @@ func TestStateMakeBlock(t *testing.T) { proposerAddress := state.Validators.GetProposer().Address stateVersion := state.Version.Consensus - block := sf.MakeBlock(state, 2, new(types.Commit)) + block := statefactory.MakeBlock(state, 2, new(types.Commit)) // test we set some fields assert.Equal(t, stateVersion, block.Version) diff --git a/internal/state/store_test.go b/internal/state/store_test.go index 939878d40..118350fff 100644 --- a/internal/state/store_test.go +++ b/internal/state/store_test.go @@ -7,11 +7,10 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - dbm "github.com/tendermint/tm-db" abci "github.com/tendermint/tendermint/abci/types" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" sm "github.com/tendermint/tendermint/internal/state" @@ -102,13 +101,13 @@ func TestStoreLoadValidators(t *testing.T) { func BenchmarkLoadValidators(b *testing.B) { const valSetSize = 100 - config := cfg.ResetTestRoot("state_") - defer os.RemoveAll(config.RootDir) - dbType := dbm.BackendType(config.DBBackend) - stateDB, err := dbm.NewDB("state", dbType, config.DBDir()) + cfg := config.ResetTestRoot("state_") + defer os.RemoveAll(cfg.RootDir) + dbType := dbm.BackendType(cfg.DBBackend) + stateDB, err := dbm.NewDB("state", dbType, cfg.DBDir()) require.NoError(b, err) stateStore := sm.NewStore(stateDB) - state, err := sm.MakeGenesisStateFromFile(config.GenesisFile()) + state, err := sm.MakeGenesisStateFromFile(cfg.GenesisFile()) if err != nil { b.Fatal(err) } diff --git a/internal/state/tx_filter.go b/internal/state/tx_filter.go index 61340e135..871e08ae6 100644 --- a/internal/state/tx_filter.go +++ b/internal/state/tx_filter.go @@ -1,22 +1,22 @@ package state import ( - mempl "github.com/tendermint/tendermint/internal/mempool" + "github.com/tendermint/tendermint/internal/mempool" "github.com/tendermint/tendermint/types" ) // TxPreCheck returns a function to filter transactions before processing. // The function limits the size of a transaction to the block's maximum data size. -func TxPreCheck(state State) mempl.PreCheckFunc { +func TxPreCheck(state State) mempool.PreCheckFunc { maxDataBytes := types.MaxDataBytesNoEvidence( state.ConsensusParams.Block.MaxBytes, state.Validators.Size(), ) - return mempl.PreCheckMaxBytes(maxDataBytes) + return mempool.PreCheckMaxBytes(maxDataBytes) } // TxPostCheck returns a function to filter transactions after processing. // The function limits the gas wanted by a transaction to the block's maximum total gas. -func TxPostCheck(state State) mempl.PostCheckFunc { - return mempl.PostCheckMaxGas(state.ConsensusParams.Block.MaxGas) +func TxPostCheck(state State) mempool.PostCheckFunc { + return mempool.PostCheckMaxGas(state.ConsensusParams.Block.MaxGas) } diff --git a/internal/state/validation_test.go b/internal/state/validation_test.go index 328c67c08..d2427f35a 100644 --- a/internal/state/validation_test.go +++ b/internal/state/validation_test.go @@ -8,6 +8,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" + dbm "github.com/tendermint/tm-db" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/crypto/ed25519" @@ -15,14 +16,13 @@ import ( memmock "github.com/tendermint/tendermint/internal/mempool/mock" sm "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/internal/state/mocks" - sf "github.com/tendermint/tendermint/internal/state/test/factory" - "github.com/tendermint/tendermint/internal/test/factory" + statefactory "github.com/tendermint/tendermint/internal/state/test/factory" + testfactory "github.com/tendermint/tendermint/internal/test/factory" "github.com/tendermint/tendermint/libs/log" tmtime "github.com/tendermint/tendermint/libs/time" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" - dbm "github.com/tendermint/tm-db" ) const validationTestsStopHeight int64 = 10 @@ -90,7 +90,7 @@ func TestValidateBlockHeader(t *testing.T) { Invalid blocks don't pass */ for _, tc := range testCases { - block := sf.MakeBlock(state, height, lastCommit) + block := statefactory.MakeBlock(state, height, lastCommit) tc.malleateBlock(block) err := blockExec.ValidateBlock(state, block) t.Logf("%s: %v", tc.name, err) @@ -107,7 +107,7 @@ func TestValidateBlockHeader(t *testing.T) { } nextHeight := validationTestsStopHeight - block := sf.MakeBlock(state, nextHeight, lastCommit) + block := statefactory.MakeBlock(state, nextHeight, lastCommit) state.InitialHeight = nextHeight + 1 err := blockExec.ValidateBlock(state, block) require.Error(t, err, "expected an error when state is ahead of block") @@ -141,7 +141,7 @@ func TestValidateBlockCommit(t *testing.T) { #2589: ensure state.LastValidators.VerifyCommit fails here */ // should be height-1 instead of height - wrongHeightVote, err := factory.MakeVote( + wrongHeightVote, err := testfactory.MakeVote( privVals[proposerAddr.String()], chainID, 1, @@ -158,7 +158,7 @@ func TestValidateBlockCommit(t *testing.T) { state.LastBlockID, []types.CommitSig{wrongHeightVote.CommitSig()}, ) - block := sf.MakeBlock(state, height, wrongHeightCommit) + block := statefactory.MakeBlock(state, height, wrongHeightCommit) err = blockExec.ValidateBlock(state, block) _, isErrInvalidCommitHeight := err.(types.ErrInvalidCommitHeight) require.True(t, isErrInvalidCommitHeight, "expected ErrInvalidCommitHeight at height %d but got: %v", height, err) @@ -166,7 +166,7 @@ func TestValidateBlockCommit(t *testing.T) { /* #2589: test len(block.LastCommit.Signatures) == state.LastValidators.Size() */ - block = sf.MakeBlock(state, height, wrongSigsCommit) + block = statefactory.MakeBlock(state, height, wrongSigsCommit) err = blockExec.ValidateBlock(state, block) _, isErrInvalidCommitSignatures := err.(types.ErrInvalidCommitSignatures) require.True(t, isErrInvalidCommitSignatures, @@ -195,7 +195,7 @@ func TestValidateBlockCommit(t *testing.T) { /* wrongSigsCommit is fine except for the extra bad precommit */ - goodVote, err := factory.MakeVote( + goodVote, err := testfactory.MakeVote( privVals[proposerAddr.String()], chainID, 1, @@ -278,7 +278,7 @@ func TestValidateBlockEvidence(t *testing.T) { evidence = append(evidence, newEv) currentBytes += int64(len(newEv.Bytes())) } - block, _ := state.MakeBlock(height, factory.MakeTenTxs(height), lastCommit, evidence, proposerAddr) + block, _ := state.MakeBlock(height, testfactory.MakeTenTxs(height), lastCommit, evidence, proposerAddr) err := blockExec.ValidateBlock(state, block) if assert.Error(t, err) { _, ok := err.(*types.ErrEvidenceOverflow) diff --git a/internal/statesync/dispatcher.go b/internal/statesync/dispatcher.go index 37010986f..2ff93a023 100644 --- a/internal/statesync/dispatcher.go +++ b/internal/statesync/dispatcher.go @@ -9,7 +9,7 @@ import ( "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/light/provider" ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync" - proto "github.com/tendermint/tendermint/proto/tendermint/types" + tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/tendermint/tendermint/types" ) @@ -109,7 +109,7 @@ func (d *Dispatcher) dispatch(peer types.NodeID, height int64) (chan *types.Ligh // Respond allows the underlying process which receives requests on the // requestCh to respond with the respective light block. A nil response is used to // represent that the receiver of the request does not have a light block at that height. -func (d *Dispatcher) Respond(lb *proto.LightBlock, peer types.NodeID) error { +func (d *Dispatcher) Respond(lb *tmproto.LightBlock, peer types.NodeID) error { d.mtx.Lock() defer d.mtx.Unlock() diff --git a/internal/test/factory/genesis.go b/internal/test/factory/genesis.go index 31ec1674f..d3a0a8464 100644 --- a/internal/test/factory/genesis.go +++ b/internal/test/factory/genesis.go @@ -3,13 +3,13 @@ package factory import ( "sort" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" tmtime "github.com/tendermint/tendermint/libs/time" "github.com/tendermint/tendermint/types" ) func RandGenesisDoc( - config *cfg.Config, + cfg *config.Config, numValidators int, randPower bool, minPower int64) (*types.GenesisDoc, []types.PrivValidator) { @@ -29,7 +29,7 @@ func RandGenesisDoc( return &types.GenesisDoc{ GenesisTime: tmtime.Now(), InitialHeight: 1, - ChainID: config.ChainID(), + ChainID: cfg.ChainID(), Validators: validators, }, privValidators } diff --git a/light/client_test.go b/light/client_test.go index 291a3e5b1..c7c974ee5 100644 --- a/light/client_test.go +++ b/light/client_test.go @@ -11,7 +11,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/require" - dbm "github.com/tendermint/tm-db" "github.com/tendermint/tendermint/internal/test/factory" diff --git a/light/provider/http/http.go b/light/provider/http/http.go index 810e43ece..f8bf7d29e 100644 --- a/light/provider/http/http.go +++ b/light/provider/http/http.go @@ -12,7 +12,7 @@ import ( "github.com/tendermint/tendermint/light/provider" rpcclient "github.com/tendermint/tendermint/rpc/client" rpchttp "github.com/tendermint/tendermint/rpc/client/http" - 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" ) @@ -300,11 +300,11 @@ func (p *http) noBlock(e error) error { func (p *http) parseRPCError(e *rpctypes.RPCError) error { switch { // 1) check if the error indicates that the peer doesn't have the block - case strings.Contains(e.Data, ctypes.ErrHeightNotAvailable.Error()): + case strings.Contains(e.Data, coretypes.ErrHeightNotAvailable.Error()): return p.noBlock(provider.ErrLightBlockNotFound) // 2) check if the height requested is too high - case strings.Contains(e.Data, ctypes.ErrHeightExceedsChainHead.Error()): + case strings.Contains(e.Data, coretypes.ErrHeightExceedsChainHead.Error()): return p.noBlock(provider.ErrHeightTooHigh) // 3) check if the provider closed the connection diff --git a/light/proxy/routes.go b/light/proxy/routes.go index 2fdc177dc..436ae1b76 100644 --- a/light/proxy/routes.go +++ b/light/proxy/routes.go @@ -4,7 +4,7 @@ import ( "github.com/tendermint/tendermint/libs/bytes" lrpc "github.com/tendermint/tendermint/light/rpc" rpcclient "github.com/tendermint/tendermint/rpc/client" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server" rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" "github.com/tendermint/tendermint/types" @@ -52,91 +52,91 @@ func RPCRoutes(c *lrpc.Client) map[string]*rpcserver.RPCFunc { } } -type rpcHealthFunc func(ctx *rpctypes.Context) (*ctypes.ResultHealth, error) +type rpcHealthFunc func(ctx *rpctypes.Context) (*coretypes.ResultHealth, error) func makeHealthFunc(c *lrpc.Client) rpcHealthFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultHealth, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultHealth, error) { return c.Health(ctx.Context()) } } -type rpcStatusFunc func(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) +type rpcStatusFunc func(ctx *rpctypes.Context) (*coretypes.ResultStatus, error) // nolint: interfacer func makeStatusFunc(c *lrpc.Client) rpcStatusFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultStatus, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultStatus, error) { return c.Status(ctx.Context()) } } -type rpcNetInfoFunc func(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) +type rpcNetInfoFunc func(ctx *rpctypes.Context) (*coretypes.ResultNetInfo, error) func makeNetInfoFunc(c *lrpc.Client) rpcNetInfoFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultNetInfo, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultNetInfo, error) { return c.NetInfo(ctx.Context()) } } -type rpcBlockchainInfoFunc func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) +type rpcBlockchainInfoFunc func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) //nolint:lll func makeBlockchainInfoFunc(c *lrpc.Client) rpcBlockchainInfoFunc { - return func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) { + return func(ctx *rpctypes.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { return c.BlockchainInfo(ctx.Context(), minHeight, maxHeight) } } -type rpcGenesisFunc func(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error) +type rpcGenesisFunc func(ctx *rpctypes.Context) (*coretypes.ResultGenesis, error) func makeGenesisFunc(c *lrpc.Client) rpcGenesisFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultGenesis, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultGenesis, error) { return c.Genesis(ctx.Context()) } } -type rpcGenesisChunkedFunc func(ctx *rpctypes.Context, chunk uint) (*ctypes.ResultGenesisChunk, error) +type rpcGenesisChunkedFunc func(ctx *rpctypes.Context, chunk uint) (*coretypes.ResultGenesisChunk, error) func makeGenesisChunkedFunc(c *lrpc.Client) rpcGenesisChunkedFunc { - return func(ctx *rpctypes.Context, chunk uint) (*ctypes.ResultGenesisChunk, error) { + return func(ctx *rpctypes.Context, chunk uint) (*coretypes.ResultGenesisChunk, error) { return c.GenesisChunked(ctx.Context(), chunk) } } -type rpcBlockFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlock, error) +type rpcBlockFunc func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultBlock, error) func makeBlockFunc(c *lrpc.Client) rpcBlockFunc { - return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlock, error) { + return func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultBlock, error) { return c.Block(ctx.Context(), height) } } -type rpcBlockByHashFunc func(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error) +type rpcBlockByHashFunc func(ctx *rpctypes.Context, hash []byte) (*coretypes.ResultBlock, error) func makeBlockByHashFunc(c *lrpc.Client) rpcBlockByHashFunc { - return func(ctx *rpctypes.Context, hash []byte) (*ctypes.ResultBlock, error) { + return func(ctx *rpctypes.Context, hash []byte) (*coretypes.ResultBlock, error) { return c.BlockByHash(ctx.Context(), hash) } } -type rpcBlockResultsFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlockResults, error) +type rpcBlockResultsFunc func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultBlockResults, error) func makeBlockResultsFunc(c *lrpc.Client) rpcBlockResultsFunc { - return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultBlockResults, error) { + return func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultBlockResults, error) { return c.BlockResults(ctx.Context(), height) } } -type rpcCommitFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultCommit, error) +type rpcCommitFunc func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultCommit, error) func makeCommitFunc(c *lrpc.Client) rpcCommitFunc { - return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultCommit, error) { + return func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultCommit, error) { return c.Commit(ctx.Context(), height) } } -type rpcTxFunc func(ctx *rpctypes.Context, hash []byte, prove bool) (*ctypes.ResultTx, error) +type rpcTxFunc func(ctx *rpctypes.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) func makeTxFunc(c *lrpc.Client) rpcTxFunc { - return func(ctx *rpctypes.Context, hash []byte, prove bool) (*ctypes.ResultTx, error) { + return func(ctx *rpctypes.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) { return c.Tx(ctx.Context(), hash, prove) } } @@ -147,7 +147,7 @@ type rpcTxSearchFunc func( prove bool, page, perPage *int, orderBy string, -) (*ctypes.ResultTxSearch, error) +) (*coretypes.ResultTxSearch, error) func makeTxSearchFunc(c *lrpc.Client) rpcTxSearchFunc { return func( @@ -156,7 +156,7 @@ func makeTxSearchFunc(c *lrpc.Client) rpcTxSearchFunc { prove bool, page, perPage *int, orderBy string, - ) (*ctypes.ResultTxSearch, error) { + ) (*coretypes.ResultTxSearch, error) { return c.TxSearch(ctx.Context(), query, prove, page, perPage, orderBy) } } @@ -167,7 +167,7 @@ type rpcBlockSearchFunc func( prove bool, page, perPage *int, orderBy string, -) (*ctypes.ResultBlockSearch, error) +) (*coretypes.ResultBlockSearch, error) func makeBlockSearchFunc(c *lrpc.Client) rpcBlockSearchFunc { return func( @@ -176,90 +176,90 @@ func makeBlockSearchFunc(c *lrpc.Client) rpcBlockSearchFunc { prove bool, page, perPage *int, orderBy string, - ) (*ctypes.ResultBlockSearch, error) { + ) (*coretypes.ResultBlockSearch, error) { return c.BlockSearch(ctx.Context(), query, page, perPage, orderBy) } } type rpcValidatorsFunc func(ctx *rpctypes.Context, height *int64, - page, perPage *int) (*ctypes.ResultValidators, error) + page, perPage *int) (*coretypes.ResultValidators, error) func makeValidatorsFunc(c *lrpc.Client) rpcValidatorsFunc { - return func(ctx *rpctypes.Context, height *int64, page, perPage *int) (*ctypes.ResultValidators, error) { + return func(ctx *rpctypes.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) { return c.Validators(ctx.Context(), height, page, perPage) } } -type rpcDumpConsensusStateFunc func(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState, error) +type rpcDumpConsensusStateFunc func(ctx *rpctypes.Context) (*coretypes.ResultDumpConsensusState, error) func makeDumpConsensusStateFunc(c *lrpc.Client) rpcDumpConsensusStateFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultDumpConsensusState, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultDumpConsensusState, error) { return c.DumpConsensusState(ctx.Context()) } } -type rpcConsensusStateFunc func(ctx *rpctypes.Context) (*ctypes.ResultConsensusState, error) +type rpcConsensusStateFunc func(ctx *rpctypes.Context) (*coretypes.ResultConsensusState, error) func makeConsensusStateFunc(c *lrpc.Client) rpcConsensusStateFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultConsensusState, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultConsensusState, error) { return c.ConsensusState(ctx.Context()) } } -type rpcConsensusParamsFunc func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultConsensusParams, error) +type rpcConsensusParamsFunc func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultConsensusParams, error) func makeConsensusParamsFunc(c *lrpc.Client) rpcConsensusParamsFunc { - return func(ctx *rpctypes.Context, height *int64) (*ctypes.ResultConsensusParams, error) { + return func(ctx *rpctypes.Context, height *int64) (*coretypes.ResultConsensusParams, error) { return c.ConsensusParams(ctx.Context(), height) } } -type rpcUnconfirmedTxsFunc func(ctx *rpctypes.Context, limit *int) (*ctypes.ResultUnconfirmedTxs, error) +type rpcUnconfirmedTxsFunc func(ctx *rpctypes.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) func makeUnconfirmedTxsFunc(c *lrpc.Client) rpcUnconfirmedTxsFunc { - return func(ctx *rpctypes.Context, limit *int) (*ctypes.ResultUnconfirmedTxs, error) { + return func(ctx *rpctypes.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) { return c.UnconfirmedTxs(ctx.Context(), limit) } } -type rpcNumUnconfirmedTxsFunc func(ctx *rpctypes.Context) (*ctypes.ResultUnconfirmedTxs, error) +type rpcNumUnconfirmedTxsFunc func(ctx *rpctypes.Context) (*coretypes.ResultUnconfirmedTxs, error) func makeNumUnconfirmedTxsFunc(c *lrpc.Client) rpcNumUnconfirmedTxsFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultUnconfirmedTxs, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultUnconfirmedTxs, error) { return c.NumUnconfirmedTxs(ctx.Context()) } } -type rpcBroadcastTxCommitFunc func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) +type rpcBroadcastTxCommitFunc func(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) func makeBroadcastTxCommitFunc(c *lrpc.Client) rpcBroadcastTxCommitFunc { - return func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { + return func(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { return c.BroadcastTxCommit(ctx.Context(), tx) } } -type rpcBroadcastTxSyncFunc func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) +type rpcBroadcastTxSyncFunc func(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) func makeBroadcastTxSyncFunc(c *lrpc.Client) rpcBroadcastTxSyncFunc { - return func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { + return func(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.BroadcastTxSync(ctx.Context(), tx) } } -type rpcBroadcastTxAsyncFunc func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) +type rpcBroadcastTxAsyncFunc func(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) func makeBroadcastTxAsyncFunc(c *lrpc.Client) rpcBroadcastTxAsyncFunc { - return func(ctx *rpctypes.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { + return func(ctx *rpctypes.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.BroadcastTxAsync(ctx.Context(), tx) } } type rpcABCIQueryFunc func(ctx *rpctypes.Context, path string, - data bytes.HexBytes, height int64, prove bool) (*ctypes.ResultABCIQuery, error) + data bytes.HexBytes, height int64, prove bool) (*coretypes.ResultABCIQuery, error) func makeABCIQueryFunc(c *lrpc.Client) rpcABCIQueryFunc { return func(ctx *rpctypes.Context, path string, data bytes.HexBytes, - height int64, prove bool) (*ctypes.ResultABCIQuery, error) { + height int64, prove bool) (*coretypes.ResultABCIQuery, error) { return c.ABCIQueryWithOptions(ctx.Context(), path, data, rpcclient.ABCIQueryOptions{ Height: height, @@ -268,19 +268,19 @@ func makeABCIQueryFunc(c *lrpc.Client) rpcABCIQueryFunc { } } -type rpcABCIInfoFunc func(ctx *rpctypes.Context) (*ctypes.ResultABCIInfo, error) +type rpcABCIInfoFunc func(ctx *rpctypes.Context) (*coretypes.ResultABCIInfo, error) func makeABCIInfoFunc(c *lrpc.Client) rpcABCIInfoFunc { - return func(ctx *rpctypes.Context) (*ctypes.ResultABCIInfo, error) { + return func(ctx *rpctypes.Context) (*coretypes.ResultABCIInfo, error) { return c.ABCIInfo(ctx.Context()) } } -type rpcBroadcastEvidenceFunc func(ctx *rpctypes.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) +type rpcBroadcastEvidenceFunc func(ctx *rpctypes.Context, ev types.Evidence) (*coretypes.ResultBroadcastEvidence, error) // nolint: interfacer func makeBroadcastEvidenceFunc(c *lrpc.Client) rpcBroadcastEvidenceFunc { - return func(ctx *rpctypes.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) { + return func(ctx *rpctypes.Context, ev types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { return c.BroadcastEvidence(ctx.Context(), ev) } } diff --git a/light/rpc/client.go b/light/rpc/client.go index 16d5a5427..4461028cd 100644 --- a/light/rpc/client.go +++ b/light/rpc/client.go @@ -16,7 +16,7 @@ import ( tmmath "github.com/tendermint/tendermint/libs/math" service "github.com/tendermint/tendermint/libs/service" rpcclient "github.com/tendermint/tendermint/rpc/client" - 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" ) @@ -113,22 +113,22 @@ func (c *Client) OnStop() { } } -func (c *Client) Status(ctx context.Context) (*ctypes.ResultStatus, error) { +func (c *Client) Status(ctx context.Context) (*coretypes.ResultStatus, error) { return c.next.Status(ctx) } -func (c *Client) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) { +func (c *Client) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { return c.next.ABCIInfo(ctx) } // ABCIQuery requests proof by default. -func (c *Client) ABCIQuery(ctx context.Context, path string, data tmbytes.HexBytes) (*ctypes.ResultABCIQuery, error) { +func (c *Client) ABCIQuery(ctx context.Context, path string, data tmbytes.HexBytes) (*coretypes.ResultABCIQuery, error) { //nolint:lll return c.ABCIQueryWithOptions(ctx, path, data, rpcclient.DefaultABCIQueryOptions) } // ABCIQueryWithOptions returns an error if opts.Prove is false. func (c *Client) ABCIQueryWithOptions(ctx context.Context, path string, data tmbytes.HexBytes, - opts rpcclient.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) { + opts rpcclient.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { // always request the proof opts.Prove = true @@ -150,7 +150,7 @@ func (c *Client) ABCIQueryWithOptions(ctx context.Context, path string, data tmb return nil, errors.New("no proof ops") } if resp.Height <= 0 { - return nil, ctypes.ErrZeroOrNegativeHeight + return nil, coretypes.ErrZeroOrNegativeHeight } // Update the light client if we're behind. @@ -185,46 +185,46 @@ func (c *Client) ABCIQueryWithOptions(ctx context.Context, path string, data tmb } } - return &ctypes.ResultABCIQuery{Response: resp}, nil + return &coretypes.ResultABCIQuery{Response: resp}, nil } -func (c *Client) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { +func (c *Client) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { return c.next.BroadcastTxCommit(ctx, tx) } -func (c *Client) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (c *Client) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.next.BroadcastTxAsync(ctx, tx) } -func (c *Client) BroadcastTxSync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (c *Client) BroadcastTxSync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.next.BroadcastTxSync(ctx, tx) } -func (c *Client) UnconfirmedTxs(ctx context.Context, limit *int) (*ctypes.ResultUnconfirmedTxs, error) { +func (c *Client) UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) { return c.next.UnconfirmedTxs(ctx, limit) } -func (c *Client) NumUnconfirmedTxs(ctx context.Context) (*ctypes.ResultUnconfirmedTxs, error) { +func (c *Client) NumUnconfirmedTxs(ctx context.Context) (*coretypes.ResultUnconfirmedTxs, error) { return c.next.NumUnconfirmedTxs(ctx) } -func (c *Client) CheckTx(ctx context.Context, tx types.Tx) (*ctypes.ResultCheckTx, error) { +func (c *Client) CheckTx(ctx context.Context, tx types.Tx) (*coretypes.ResultCheckTx, error) { return c.next.CheckTx(ctx, tx) } -func (c *Client) NetInfo(ctx context.Context) (*ctypes.ResultNetInfo, error) { +func (c *Client) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) { return c.next.NetInfo(ctx) } -func (c *Client) DumpConsensusState(ctx context.Context) (*ctypes.ResultDumpConsensusState, error) { +func (c *Client) DumpConsensusState(ctx context.Context) (*coretypes.ResultDumpConsensusState, error) { return c.next.DumpConsensusState(ctx) } -func (c *Client) ConsensusState(ctx context.Context) (*ctypes.ResultConsensusState, error) { +func (c *Client) ConsensusState(ctx context.Context) (*coretypes.ResultConsensusState, error) { return c.next.ConsensusState(ctx) } -func (c *Client) ConsensusParams(ctx context.Context, height *int64) (*ctypes.ResultConsensusParams, error) { +func (c *Client) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) { res, err := c.next.ConsensusParams(ctx, height) if err != nil { return nil, err @@ -235,7 +235,7 @@ func (c *Client) ConsensusParams(ctx context.Context, height *int64) (*ctypes.Re return nil, err } if res.BlockHeight <= 0 { - return nil, ctypes.ErrZeroOrNegativeHeight + return nil, coretypes.ErrZeroOrNegativeHeight } // Update the light client if we're behind. @@ -253,13 +253,13 @@ func (c *Client) ConsensusParams(ctx context.Context, height *int64) (*ctypes.Re return res, nil } -func (c *Client) Health(ctx context.Context) (*ctypes.ResultHealth, error) { +func (c *Client) Health(ctx context.Context) (*coretypes.ResultHealth, error) { return c.next.Health(ctx) } // BlockchainInfo calls rpcclient#BlockchainInfo and then verifies every header // returned. -func (c *Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) { +func (c *Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { //nolint:lll res, err := c.next.BlockchainInfo(ctx, minHeight, maxHeight) if err != nil { return nil, err @@ -298,16 +298,16 @@ func (c *Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) return res, nil } -func (c *Client) Genesis(ctx context.Context) (*ctypes.ResultGenesis, error) { +func (c *Client) Genesis(ctx context.Context) (*coretypes.ResultGenesis, error) { return c.next.Genesis(ctx) } -func (c *Client) GenesisChunked(ctx context.Context, id uint) (*ctypes.ResultGenesisChunk, error) { +func (c *Client) GenesisChunked(ctx context.Context, id uint) (*coretypes.ResultGenesisChunk, error) { return c.next.GenesisChunked(ctx, id) } // Block calls rpcclient#Block and then verifies the result. -func (c *Client) Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error) { +func (c *Client) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { res, err := c.next.Block(ctx, height) if err != nil { return nil, err @@ -341,7 +341,7 @@ func (c *Client) Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, } // BlockByHash calls rpcclient#BlockByHash and then verifies the result. -func (c *Client) BlockByHash(ctx context.Context, hash tmbytes.HexBytes) (*ctypes.ResultBlock, error) { +func (c *Client) BlockByHash(ctx context.Context, hash tmbytes.HexBytes) (*coretypes.ResultBlock, error) { res, err := c.next.BlockByHash(ctx, hash) if err != nil { return nil, err @@ -376,7 +376,7 @@ func (c *Client) BlockByHash(ctx context.Context, hash tmbytes.HexBytes) (*ctype // BlockResults returns the block results for the given height. If no height is // provided, the results of the block preceding the latest are returned. -func (c *Client) BlockResults(ctx context.Context, height *int64) (*ctypes.ResultBlockResults, error) { +func (c *Client) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) { var h int64 if height == nil { res, err := c.next.Status(ctx) @@ -397,7 +397,7 @@ func (c *Client) BlockResults(ctx context.Context, height *int64) (*ctypes.Resul // Validate res. if res.Height <= 0 { - return nil, ctypes.ErrZeroOrNegativeHeight + return nil, coretypes.ErrZeroOrNegativeHeight } // Update the light client if we're behind. @@ -438,7 +438,7 @@ func (c *Client) BlockResults(ctx context.Context, height *int64) (*ctypes.Resul return res, nil } -func (c *Client) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) { +func (c *Client) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { // Update the light client if we're behind and retrieve the light block at the requested height // or at the latest height if no height is provided. l, err := c.updateLightClientIfNeededTo(ctx, height) @@ -446,7 +446,7 @@ func (c *Client) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommi return nil, err } - return &ctypes.ResultCommit{ + return &coretypes.ResultCommit{ SignedHeader: *l.SignedHeader, CanonicalCommit: true, }, nil @@ -454,7 +454,7 @@ func (c *Client) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommi // Tx calls rpcclient#Tx method and then verifies the proof if such was // requested. -func (c *Client) Tx(ctx context.Context, hash tmbytes.HexBytes, prove bool) (*ctypes.ResultTx, error) { +func (c *Client) Tx(ctx context.Context, hash tmbytes.HexBytes, prove bool) (*coretypes.ResultTx, error) { res, err := c.next.Tx(ctx, hash, prove) if err != nil || !prove { return res, err @@ -462,7 +462,7 @@ func (c *Client) Tx(ctx context.Context, hash tmbytes.HexBytes, prove bool) (*ct // Validate res. if res.Height <= 0 { - return nil, ctypes.ErrZeroOrNegativeHeight + return nil, coretypes.ErrZeroOrNegativeHeight } // Update the light client if we're behind. @@ -481,7 +481,7 @@ func (c *Client) TxSearch( prove bool, page, perPage *int, orderBy string, -) (*ctypes.ResultTxSearch, error) { +) (*coretypes.ResultTxSearch, error) { return c.next.TxSearch(ctx, query, prove, page, perPage, orderBy) } @@ -490,7 +490,7 @@ func (c *Client) BlockSearch( query string, page, perPage *int, orderBy string, -) (*ctypes.ResultBlockSearch, error) { +) (*coretypes.ResultBlockSearch, error) { return c.next.BlockSearch(ctx, query, page, perPage, orderBy) } @@ -499,7 +499,7 @@ func (c *Client) Validators( ctx context.Context, height *int64, pagePtr, perPagePtr *int, -) (*ctypes.ResultValidators, error) { +) (*coretypes.ResultValidators, error) { // Update the light client if we're behind and retrieve the light block at the // requested height or at the latest height if no height is provided. @@ -518,19 +518,19 @@ func (c *Client) Validators( skipCount := validateSkipCount(page, perPage) v := l.ValidatorSet.Validators[skipCount : skipCount+tmmath.MinInt(perPage, totalCount-skipCount)] - return &ctypes.ResultValidators{ + return &coretypes.ResultValidators{ BlockHeight: l.Height, Validators: v, Count: len(v), Total: totalCount}, nil } -func (c *Client) BroadcastEvidence(ctx context.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) { +func (c *Client) BroadcastEvidence(ctx context.Context, ev types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { return c.next.BroadcastEvidence(ctx, ev) } func (c *Client) Subscribe(ctx context.Context, subscriber, query string, - outCapacity ...int) (out <-chan ctypes.ResultEvent, err error) { + outCapacity ...int) (out <-chan coretypes.ResultEvent, err error) { return c.next.Subscribe(ctx, subscriber, query, outCapacity...) } @@ -565,7 +565,7 @@ func (c *Client) RegisterOpDecoder(typ string, dec merkle.OpDecoder) { // SubscribeWS subscribes for events using the given query and remote address as // a subscriber, but does not verify responses (UNSAFE)! // TODO: verify data -func (c *Client) SubscribeWS(ctx *rpctypes.Context, query string) (*ctypes.ResultSubscribe, error) { +func (c *Client) SubscribeWS(ctx *rpctypes.Context, query string) (*coretypes.ResultSubscribe, error) { out, err := c.next.Subscribe(context.Background(), ctx.RemoteAddr(), query) if err != nil { return nil, err @@ -588,27 +588,27 @@ func (c *Client) SubscribeWS(ctx *rpctypes.Context, query string) (*ctypes.Resul } }() - return &ctypes.ResultSubscribe{}, nil + return &coretypes.ResultSubscribe{}, nil } // UnsubscribeWS calls original client's Unsubscribe using remote address as a // subscriber. -func (c *Client) UnsubscribeWS(ctx *rpctypes.Context, query string) (*ctypes.ResultUnsubscribe, error) { +func (c *Client) UnsubscribeWS(ctx *rpctypes.Context, query string) (*coretypes.ResultUnsubscribe, error) { err := c.next.Unsubscribe(context.Background(), ctx.RemoteAddr(), query) if err != nil { return nil, err } - return &ctypes.ResultUnsubscribe{}, nil + return &coretypes.ResultUnsubscribe{}, nil } // UnsubscribeAllWS calls original client's UnsubscribeAll using remote address // as a subscriber. -func (c *Client) UnsubscribeAllWS(ctx *rpctypes.Context) (*ctypes.ResultUnsubscribe, error) { +func (c *Client) UnsubscribeAllWS(ctx *rpctypes.Context) (*coretypes.ResultUnsubscribe, error) { err := c.next.UnsubscribeAll(context.Background(), ctx.RemoteAddr()) if err != nil { return nil, err } - return &ctypes.ResultUnsubscribe{}, nil + return &coretypes.ResultUnsubscribe{}, nil } // XXX: Copied from rpc/core/env.go @@ -620,7 +620,7 @@ const ( func validatePage(pagePtr *int, perPage, totalCount int) (int, error) { 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 @@ -633,7 +633,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 diff --git a/light/store/db/db_test.go b/light/store/db/db_test.go index b373d5126..7f963eb92 100644 --- a/light/store/db/db_test.go +++ b/light/store/db/db_test.go @@ -7,7 +7,6 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - dbm "github.com/tendermint/tm-db" "github.com/tendermint/tendermint/crypto" diff --git a/node/node.go b/node/node.go index c2bf88fde..4e44a5678 100644 --- a/node/node.go +++ b/node/node.go @@ -6,19 +6,17 @@ import ( "fmt" "net" "net/http" - _ "net/http/pprof" // nolint: gosec // securely exposed on separate, optional port "strconv" "time" - _ "github.com/lib/pq" // provide the psql db driver "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/config" "github.com/tendermint/tendermint/crypto" - cs "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/mempool" "github.com/tendermint/tendermint/internal/p2p" "github.com/tendermint/tendermint/internal/p2p/pex" @@ -38,6 +36,10 @@ import ( rpcserver "github.com/tendermint/tendermint/rpc/jsonrpc/server" "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" + + _ "net/http/pprof" // nolint: gosec // securely exposed on separate, optional port + + _ "github.com/lib/pq" // provide the psql db driver ) // nodeImpl is the highest level interface to a full Tendermint node. @@ -46,7 +48,7 @@ type nodeImpl struct { service.BaseService // config - config *cfg.Config + config *config.Config genesisDoc *types.GenesisDoc // initial validator set privValidator types.PrivValidator // local node's validator key @@ -69,7 +71,7 @@ type nodeImpl struct { mempool mempool.Mempool stateSync bool // whether the node should state sync on startup stateSyncReactor *statesync.Reactor // for hosting and restoring state sync snapshots - consensusReactor *cs.Reactor // for participating in the consensus + consensusReactor *consensus.Reactor // for participating in the consensus pexReactor service.Service // for exchanging peer addresses evidenceReactor service.Service rpcListeners []net.Listener // rpc servers @@ -81,23 +83,23 @@ type nodeImpl struct { // newDefaultNode returns a Tendermint node with default settings for the // PrivValidator, ClientCreator, GenesisDoc, and DBProvider. // It implements NodeProvider. -func newDefaultNode(config *cfg.Config, logger log.Logger) (service.Service, error) { - nodeKey, err := types.LoadOrGenNodeKey(config.NodeKeyFile()) +func newDefaultNode(cfg *config.Config, logger log.Logger) (service.Service, error) { + nodeKey, err := types.LoadOrGenNodeKey(cfg.NodeKeyFile()) if err != nil { - return nil, fmt.Errorf("failed to load or gen node key %s: %w", config.NodeKeyFile(), err) + return nil, fmt.Errorf("failed to load or gen node key %s: %w", cfg.NodeKeyFile(), err) } - if config.Mode == cfg.ModeSeed { - return makeSeedNode(config, - cfg.DefaultDBProvider, + if cfg.Mode == config.ModeSeed { + return makeSeedNode(cfg, + config.DefaultDBProvider, nodeKey, - defaultGenesisDocProviderFunc(config), + defaultGenesisDocProviderFunc(cfg), logger, ) } var pval *privval.FilePV - if config.Mode == cfg.ModeValidator { - pval, err = privval.LoadOrGenFilePV(config.PrivValidator.KeyFile(), config.PrivValidator.StateFile()) + if cfg.Mode == config.ModeValidator { + pval, err = privval.LoadOrGenFilePV(cfg.PrivValidator.KeyFile(), cfg.PrivValidator.StateFile()) if err != nil { return nil, err } @@ -105,27 +107,27 @@ func newDefaultNode(config *cfg.Config, logger log.Logger) (service.Service, err pval = nil } - appClient, _ := proxy.DefaultClientCreator(config.ProxyApp, config.ABCI, config.DBDir()) - return makeNode(config, + appClient, _ := proxy.DefaultClientCreator(cfg.ProxyApp, cfg.ABCI, cfg.DBDir()) + return makeNode(cfg, pval, nodeKey, appClient, - defaultGenesisDocProviderFunc(config), - cfg.DefaultDBProvider, + defaultGenesisDocProviderFunc(cfg), + config.DefaultDBProvider, logger, ) } // makeNode returns a new, ready to go, Tendermint Node. -func makeNode(config *cfg.Config, +func makeNode(cfg *config.Config, privValidator types.PrivValidator, nodeKey types.NodeKey, clientCreator abciclient.Creator, genesisDocProvider genesisDocProvider, - dbProvider cfg.DBProvider, + dbProvider config.DBProvider, logger log.Logger) (service.Service, error) { - blockStore, stateDB, err := initDBs(config, dbProvider) + blockStore, stateDB, err := initDBs(cfg, dbProvider) if err != nil { return nil, err } @@ -161,31 +163,31 @@ func makeNode(config *cfg.Config, return nil, err } - indexerService, eventSinks, err := createAndStartIndexerService(config, dbProvider, eventBus, logger, genDoc.ChainID) + indexerService, eventSinks, err := createAndStartIndexerService(cfg, dbProvider, eventBus, logger, genDoc.ChainID) if err != nil { return nil, err } // If an address is provided, listen on the socket for a connection from an // external signing process. - if config.PrivValidator.ListenAddr != "" { - protocol, _ := tmnet.ProtocolAndAddress(config.PrivValidator.ListenAddr) + if cfg.PrivValidator.ListenAddr != "" { + protocol, _ := tmnet.ProtocolAndAddress(cfg.PrivValidator.ListenAddr) // FIXME: we should start services inside OnStart switch protocol { case "grpc": - privValidator, err = createAndStartPrivValidatorGRPCClient(config, genDoc.ChainID, logger) + privValidator, err = createAndStartPrivValidatorGRPCClient(cfg, genDoc.ChainID, logger) if err != nil { return nil, fmt.Errorf("error with private validator grpc client: %w", err) } default: - privValidator, err = createAndStartPrivValidatorSocketClient(config.PrivValidator.ListenAddr, genDoc.ChainID, logger) + privValidator, err = createAndStartPrivValidatorSocketClient(cfg.PrivValidator.ListenAddr, genDoc.ChainID, logger) if err != nil { return nil, fmt.Errorf("error with private validator socket client: %w", err) } } } var pubKey crypto.PubKey - if config.Mode == cfg.ModeValidator { + if cfg.Mode == config.ModeValidator { pubKey, err = privValidator.GetPubKey(context.TODO()) if err != nil { return nil, fmt.Errorf("can't get pubkey: %w", err) @@ -196,7 +198,7 @@ func makeNode(config *cfg.Config, } // Determine whether we should attempt state sync. - stateSync := config.StateSync.Enable && !onlyValidatorIsUs(state, pubKey) + stateSync := cfg.StateSync.Enable && !onlyValidatorIsUs(state, pubKey) if stateSync && state.LastBlockHeight > 0 { logger.Info("Found local state with non-zero height, skipping state sync") stateSync = false @@ -221,43 +223,43 @@ func makeNode(config *cfg.Config, // Determine whether we should do block sync. This must happen after the handshake, since the // app may modify the validator set, specifying ourself as the only validator. - blockSync := config.BlockSync.Enable && !onlyValidatorIsUs(state, pubKey) + blockSync := cfg.BlockSync.Enable && !onlyValidatorIsUs(state, pubKey) - logNodeStartupInfo(state, pubKey, logger, consensusLogger, config.Mode) + logNodeStartupInfo(state, pubKey, logger, consensusLogger, cfg.Mode) // TODO: Fetch and provide real options and do proper p2p bootstrapping. // TODO: Use a persistent peer database. - nodeInfo, err := makeNodeInfo(config, nodeKey, eventSinks, genDoc, state) + nodeInfo, err := makeNodeInfo(cfg, nodeKey, eventSinks, genDoc, state) if err != nil { return nil, err } p2pLogger := logger.With("module", "p2p") - transport := createTransport(p2pLogger, config) + transport := createTransport(p2pLogger, cfg) - peerManager, err := createPeerManager(config, dbProvider, p2pLogger, nodeKey.ID) + peerManager, err := createPeerManager(cfg, dbProvider, p2pLogger, nodeKey.ID) if err != nil { return nil, fmt.Errorf("failed to create peer manager: %w", err) } nodeMetrics := - defaultMetricsProvider(config.Instrumentation)(genDoc.ChainID) + defaultMetricsProvider(cfg.Instrumentation)(genDoc.ChainID) router, err := createRouter(p2pLogger, nodeMetrics.p2p, nodeInfo, nodeKey.PrivKey, - peerManager, transport, getRouterConfig(config, proxyApp)) + peerManager, transport, getRouterConfig(cfg, proxyApp)) if err != nil { return nil, fmt.Errorf("failed to create router: %w", err) } mpReactorShim, mpReactor, mp, err := createMempoolReactor( - config, proxyApp, state, nodeMetrics.mempool, peerManager, router, logger, + cfg, proxyApp, state, nodeMetrics.mempool, peerManager, router, logger, ) if err != nil { return nil, err } evReactorShim, evReactor, evPool, err := createEvidenceReactor( - config, dbProvider, stateDB, blockStore, peerManager, router, logger, + cfg, dbProvider, stateDB, blockStore, peerManager, router, logger, ) if err != nil { return nil, err @@ -275,16 +277,16 @@ func makeNode(config *cfg.Config, ) csReactorShim, csReactor, csState := createConsensusReactor( - config, state, blockExec, blockStore, mp, evPool, - privValidator, nodeMetrics.cs, stateSync || blockSync, eventBus, + cfg, state, blockExec, blockStore, mp, evPool, + privValidator, nodeMetrics.consensus, stateSync || blockSync, eventBus, peerManager, router, consensusLogger, ) // Create the blockchain reactor. Note, we do not start block sync if we're // doing a state sync first. bcReactorShim, bcReactor, err := createBlockchainReactor( - logger, config, state, blockExec, blockStore, csReactor, - peerManager, router, blockSync && !stateSync, nodeMetrics.cs, + logger, cfg, state, blockExec, blockStore, csReactor, + peerManager, router, blockSync && !stateSync, nodeMetrics.consensus, ) if err != nil { return nil, fmt.Errorf("could not create blockchain reactor: %w", err) @@ -301,9 +303,9 @@ func makeNode(config *cfg.Config, // Make ConsensusReactor. Don't enable fully if doing a state sync and/or block sync first. // FIXME We need to update metrics here, since other reactors don't have access to them. if stateSync { - nodeMetrics.cs.StateSyncing.Set(1) + nodeMetrics.consensus.StateSyncing.Set(1) } else if blockSync { - nodeMetrics.cs.BlockSyncing.Set(1) + nodeMetrics.consensus.BlockSyncing.Set(1) } // Set up state sync reactor, and schedule a sync if requested. @@ -320,7 +322,7 @@ func makeNode(config *cfg.Config, stateSyncReactorShim = p2p.NewReactorShim(logger.With("module", "statesync"), "StateSyncShim", statesync.ChannelShims) - if config.P2P.UseLegacy { + if cfg.P2P.UseLegacy { channels = getChannelsFromShim(stateSyncReactorShim) peerUpdates = stateSyncReactorShim.PeerUpdates } else { @@ -331,7 +333,7 @@ func makeNode(config *cfg.Config, stateSyncReactor = statesync.NewReactor( genDoc.ChainID, genDoc.InitialHeight, - *config.StateSync, + *cfg.StateSync, stateSyncReactorShim.Logger, proxyApp.Snapshot(), proxyApp.Query(), @@ -342,7 +344,7 @@ func makeNode(config *cfg.Config, peerUpdates, stateStore, blockStore, - config.StateSync.TempDir, + cfg.StateSync.TempDir, nodeMetrics.statesync, ) @@ -378,46 +380,46 @@ func makeNode(config *cfg.Config, pexCh := pex.ChannelDescriptor() transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh}) - if config.P2P.UseLegacy { + if cfg.P2P.UseLegacy { // setup Transport and Switch sw = createSwitch( - config, transport, nodeMetrics.p2p, mpReactorShim, bcReactorForSwitch, + cfg, transport, nodeMetrics.p2p, mpReactorShim, bcReactorForSwitch, stateSyncReactorShim, csReactorShim, evReactorShim, proxyApp, nodeInfo, nodeKey, p2pLogger, ) - err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) + err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(cfg.P2P.PersistentPeers, ",", " ")) if err != nil { return nil, fmt.Errorf("could not add peers from persistent-peers field: %w", err) } - err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) + err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(cfg.P2P.UnconditionalPeerIDs, ",", " ")) if err != nil { return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) } - addrBook, err = createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) + addrBook, err = createAddrBookAndSetOnSwitch(cfg, sw, p2pLogger, nodeKey) if err != nil { return nil, fmt.Errorf("could not create addrbook: %w", err) } - pexReactor = createPEXReactorAndAddToSwitch(addrBook, config, sw, logger) + pexReactor = createPEXReactorAndAddToSwitch(addrBook, cfg, sw, logger) } else { addrBook = nil - pexReactor, err = createPEXReactorV2(config, logger, peerManager, router) + pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router) if err != nil { return nil, err } } - if config.RPC.PprofListenAddress != "" { + if cfg.RPC.PprofListenAddress != "" { go func() { - logger.Info("Starting pprof server", "laddr", config.RPC.PprofListenAddress) - logger.Error("pprof server error", "err", http.ListenAndServe(config.RPC.PprofListenAddress, nil)) + logger.Info("Starting pprof server", "laddr", cfg.RPC.PprofListenAddress) + logger.Error("pprof server error", "err", http.ListenAndServe(cfg.RPC.PprofListenAddress, nil)) }() } node := &nodeImpl{ - config: config, + config: cfg, genesisDoc: genDoc, privValidator: privValidator, @@ -452,7 +454,7 @@ func makeNode(config *cfg.Config, ConsensusState: csState, ConsensusReactor: csReactor, - BlockSyncReactor: bcReactor.(cs.BlockSyncReactor), + BlockSyncReactor: bcReactor.(consensus.BlockSyncReactor), P2PPeers: sw, PeerManager: peerManager, @@ -462,7 +464,7 @@ func makeNode(config *cfg.Config, EventBus: eventBus, Mempool: mp, Logger: logger.With("module", "rpc"), - Config: *config.RPC, + Config: *cfg.RPC, }, } @@ -485,8 +487,8 @@ func makeNode(config *cfg.Config, } // makeSeedNode returns a new seed node, containing only p2p, pex reactor -func makeSeedNode(config *cfg.Config, - dbProvider cfg.DBProvider, +func makeSeedNode(cfg *config.Config, + dbProvider config.DBProvider, nodeKey types.NodeKey, genesisDocProvider genesisDocProvider, logger log.Logger, @@ -502,23 +504,23 @@ func makeSeedNode(config *cfg.Config, return nil, err } - nodeInfo, err := makeSeedNodeInfo(config, nodeKey, genDoc, state) + nodeInfo, err := makeSeedNodeInfo(cfg, nodeKey, genDoc, state) if err != nil { return nil, err } // Setup Transport and Switch. - p2pMetrics := p2p.PrometheusMetrics(config.Instrumentation.Namespace, "chain_id", genDoc.ChainID) + p2pMetrics := p2p.PrometheusMetrics(cfg.Instrumentation.Namespace, "chain_id", genDoc.ChainID) p2pLogger := logger.With("module", "p2p") - transport := createTransport(p2pLogger, config) + transport := createTransport(p2pLogger, cfg) - peerManager, err := createPeerManager(config, dbProvider, p2pLogger, nodeKey.ID) + peerManager, err := createPeerManager(cfg, dbProvider, p2pLogger, nodeKey.ID) if err != nil { return nil, fmt.Errorf("failed to create peer manager: %w", err) } router, err := createRouter(p2pLogger, p2pMetrics, nodeInfo, nodeKey.PrivKey, - peerManager, transport, getRouterConfig(config, nil)) + peerManager, transport, getRouterConfig(cfg, nil)) if err != nil { return nil, fmt.Errorf("failed to create router: %w", err) } @@ -536,44 +538,44 @@ func makeSeedNode(config *cfg.Config, pexCh := pex.ChannelDescriptor() transport.AddChannelDescriptors([]*p2p.ChannelDescriptor{&pexCh}) - if config.P2P.UseLegacy { + if cfg.P2P.UseLegacy { sw = createSwitch( - config, transport, p2pMetrics, nil, nil, + cfg, transport, p2pMetrics, nil, nil, nil, nil, nil, nil, nodeInfo, nodeKey, p2pLogger, ) - err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ")) + err = sw.AddPersistentPeers(strings.SplitAndTrimEmpty(cfg.P2P.PersistentPeers, ",", " ")) if err != nil { return nil, fmt.Errorf("could not add peers from persistent_peers field: %w", err) } - err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")) + err = sw.AddUnconditionalPeerIDs(strings.SplitAndTrimEmpty(cfg.P2P.UnconditionalPeerIDs, ",", " ")) if err != nil { return nil, fmt.Errorf("could not add peer ids from unconditional_peer_ids field: %w", err) } - addrBook, err = createAddrBookAndSetOnSwitch(config, sw, p2pLogger, nodeKey) + addrBook, err = createAddrBookAndSetOnSwitch(cfg, sw, p2pLogger, nodeKey) if err != nil { return nil, fmt.Errorf("could not create addrbook: %w", err) } - pexReactor = createPEXReactorAndAddToSwitch(addrBook, config, sw, logger) + pexReactor = createPEXReactorAndAddToSwitch(addrBook, cfg, sw, logger) } else { - pexReactor, err = createPEXReactorV2(config, logger, peerManager, router) + pexReactor, err = createPEXReactorV2(cfg, logger, peerManager, router) if err != nil { return nil, err } } - if config.RPC.PprofListenAddress != "" { + if cfg.RPC.PprofListenAddress != "" { go func() { - logger.Info("Starting pprof server", "laddr", config.RPC.PprofListenAddress) - logger.Error("pprof server error", "err", http.ListenAndServe(config.RPC.PprofListenAddress, nil)) + logger.Info("Starting pprof server", "laddr", cfg.RPC.PprofListenAddress) + logger.Error("pprof server error", "err", http.ListenAndServe(cfg.RPC.PprofListenAddress, nil)) }() } node := &nodeImpl{ - config: config, + config: cfg, genesisDoc: genDoc, transport: transport, @@ -602,7 +604,7 @@ func (n *nodeImpl) OnStart() error { // Start the RPC server before the P2P server // so we can eg. receive txs for the first block - if n.config.RPC.ListenAddress != "" && n.config.Mode != cfg.ModeSeed { + if n.config.RPC.ListenAddress != "" && n.config.Mode != config.ModeSeed { listeners, err := n.startRPC() if err != nil { return err @@ -637,8 +639,8 @@ func (n *nodeImpl) OnStart() error { return err } - if n.config.Mode != cfg.ModeSeed { - if n.config.BlockSync.Version == cfg.BlockSyncV0 { + if n.config.Mode != config.ModeSeed { + if n.config.BlockSync.Version == config.BlockSyncV0 { if err := n.bcReactor.Start(); err != nil { return err } @@ -679,7 +681,7 @@ func (n *nodeImpl) OnStart() error { // TODO: We shouldn't run state sync if we already have state that has a // LastBlockHeight that is not InitialHeight if n.stateSync { - bcR, ok := n.bcReactor.(cs.BlockSyncReactor) + bcR, ok := n.bcReactor.(consensus.BlockSyncReactor) if !ok { return fmt.Errorf("this blockchain reactor does not support switching from state sync") } @@ -758,9 +760,9 @@ func (n *nodeImpl) OnStop() { n.Logger.Error("Error closing indexerService", "err", err) } - if n.config.Mode != cfg.ModeSeed { + if n.config.Mode != config.ModeSeed { // now stop the reactors - if n.config.BlockSync.Version == cfg.BlockSyncV0 { + if n.config.BlockSync.Version == config.BlockSyncV0 { // Stop the real blockchain reactor separately since the switch uses the shim. if err := n.bcReactor.Stop(); err != nil { n.Logger.Error("failed to stop the blockchain reactor", "err", err) @@ -831,7 +833,7 @@ func (n *nodeImpl) OnStop() { } func (n *nodeImpl) startRPC() ([]net.Listener, error) { - if n.config.Mode == cfg.ModeValidator { + if n.config.Mode == config.ModeValidator { pubKey, err := n.privValidator.GetPubKey(context.TODO()) if pubKey == nil || err != nil { return nil, fmt.Errorf("can't get pubkey: %w", err) @@ -849,15 +851,15 @@ func (n *nodeImpl) startRPC() ([]net.Listener, error) { n.rpcEnv.AddUnsafe(routes) } - config := rpcserver.DefaultConfig() - config.MaxBodyBytes = n.config.RPC.MaxBodyBytes - config.MaxHeaderBytes = n.config.RPC.MaxHeaderBytes - config.MaxOpenConnections = n.config.RPC.MaxOpenConnections + cfg := rpcserver.DefaultConfig() + cfg.MaxBodyBytes = n.config.RPC.MaxBodyBytes + cfg.MaxHeaderBytes = n.config.RPC.MaxHeaderBytes + cfg.MaxOpenConnections = n.config.RPC.MaxOpenConnections // If necessary adjust global WriteTimeout to ensure it's greater than // TimeoutBroadcastTxCommit. // See https://github.com/tendermint/tendermint/issues/3435 - if config.WriteTimeout <= n.config.RPC.TimeoutBroadcastTxCommit { - config.WriteTimeout = n.config.RPC.TimeoutBroadcastTxCommit + 1*time.Second + if cfg.WriteTimeout <= n.config.RPC.TimeoutBroadcastTxCommit { + cfg.WriteTimeout = n.config.RPC.TimeoutBroadcastTxCommit + 1*time.Second } // we may expose the rpc over both a unix and tcp socket @@ -873,14 +875,14 @@ func (n *nodeImpl) startRPC() ([]net.Listener, error) { wmLogger.Error("Failed to unsubscribe addr from events", "addr", remoteAddr, "err", err) } }), - rpcserver.ReadLimit(config.MaxBodyBytes), + rpcserver.ReadLimit(cfg.MaxBodyBytes), ) wm.SetLogger(wmLogger) mux.HandleFunc("/websocket", wm.WebsocketHandler) rpcserver.RegisterRPCFuncs(mux, routes, rpcLogger) listener, err := rpcserver.Listen( listenAddr, - config.MaxOpenConnections, + cfg.MaxOpenConnections, ) if err != nil { return nil, err @@ -903,7 +905,7 @@ func (n *nodeImpl) startRPC() ([]net.Listener, error) { n.config.RPC.CertFile(), n.config.RPC.KeyFile(), rpcLogger, - config, + cfg, ); err != nil { n.Logger.Error("Error serving server with TLS", "err", err) } @@ -914,7 +916,7 @@ func (n *nodeImpl) startRPC() ([]net.Listener, error) { listener, rootHandler, rpcLogger, - config, + cfg, ); err != nil { n.Logger.Error("Error serving server", "err", err) } @@ -927,18 +929,18 @@ func (n *nodeImpl) startRPC() ([]net.Listener, error) { // we expose a simplified api over grpc for convenience to app devs grpcListenAddr := n.config.RPC.GRPCListenAddress if grpcListenAddr != "" { - config := rpcserver.DefaultConfig() - config.MaxBodyBytes = n.config.RPC.MaxBodyBytes - config.MaxHeaderBytes = n.config.RPC.MaxHeaderBytes + cfg := rpcserver.DefaultConfig() + cfg.MaxBodyBytes = n.config.RPC.MaxBodyBytes + cfg.MaxHeaderBytes = n.config.RPC.MaxHeaderBytes // NOTE: GRPCMaxOpenConnections is used, not MaxOpenConnections - config.MaxOpenConnections = n.config.RPC.GRPCMaxOpenConnections + cfg.MaxOpenConnections = n.config.RPC.GRPCMaxOpenConnections // If necessary adjust global WriteTimeout to ensure it's greater than // TimeoutBroadcastTxCommit. // See https://github.com/tendermint/tendermint/issues/3435 - if config.WriteTimeout <= n.config.RPC.TimeoutBroadcastTxCommit { - config.WriteTimeout = n.config.RPC.TimeoutBroadcastTxCommit + 1*time.Second + if cfg.WriteTimeout <= n.config.RPC.TimeoutBroadcastTxCommit { + cfg.WriteTimeout = n.config.RPC.TimeoutBroadcastTxCommit + 1*time.Second } - listener, err := rpcserver.Listen(grpcListenAddr, config.MaxOpenConnections) + listener, err := rpcserver.Listen(grpcListenAddr, cfg.MaxOpenConnections) if err != nil { return nil, err } @@ -977,7 +979,7 @@ func (n *nodeImpl) startPrometheusServer(addr string) *http.Server { } // ConsensusReactor returns the Node's ConsensusReactor. -func (n *nodeImpl) ConsensusReactor() *cs.Reactor { +func (n *nodeImpl) ConsensusReactor() *consensus.Reactor { return n.consensusReactor } @@ -1031,14 +1033,14 @@ type genesisDocProvider func() (*types.GenesisDoc, error) // defaultGenesisDocProviderFunc returns a GenesisDocProvider that loads // the GenesisDoc from the config.GenesisFile() on the filesystem. -func defaultGenesisDocProviderFunc(config *cfg.Config) genesisDocProvider { +func defaultGenesisDocProviderFunc(cfg *config.Config) genesisDocProvider { return func() (*types.GenesisDoc, error) { - return types.GenesisDocFromFile(config.GenesisFile()) + return types.GenesisDocFromFile(cfg.GenesisFile()) } } type nodeMetrics struct { - cs *cs.Metrics + consensus *consensus.Metrics p2p *p2p.Metrics mempool *mempool.Metrics state *sm.Metrics @@ -1050,19 +1052,19 @@ type metricsProvider func(chainID string) *nodeMetrics // defaultMetricsProvider returns Metrics build using Prometheus client library // if Prometheus is enabled. Otherwise, it returns no-op Metrics. -func defaultMetricsProvider(config *cfg.InstrumentationConfig) metricsProvider { +func defaultMetricsProvider(cfg *config.InstrumentationConfig) metricsProvider { return func(chainID string) *nodeMetrics { - if config.Prometheus { + if cfg.Prometheus { return &nodeMetrics{ - cs.PrometheusMetrics(config.Namespace, "chain_id", chainID), - p2p.PrometheusMetrics(config.Namespace, "chain_id", chainID), - mempool.PrometheusMetrics(config.Namespace, "chain_id", chainID), - sm.PrometheusMetrics(config.Namespace, "chain_id", chainID), - statesync.PrometheusMetrics(config.Namespace, "chain_id", chainID), + consensus.PrometheusMetrics(cfg.Namespace, "chain_id", chainID), + p2p.PrometheusMetrics(cfg.Namespace, "chain_id", chainID), + mempool.PrometheusMetrics(cfg.Namespace, "chain_id", chainID), + sm.PrometheusMetrics(cfg.Namespace, "chain_id", chainID), + statesync.PrometheusMetrics(cfg.Namespace, "chain_id", chainID), } } return &nodeMetrics{ - cs.NopMetrics(), + consensus.NopMetrics(), p2p.NopMetrics(), mempool.NopMetrics(), sm.NopMetrics(), @@ -1130,15 +1132,15 @@ func createAndStartPrivValidatorSocketClient( } func createAndStartPrivValidatorGRPCClient( - config *cfg.Config, + cfg *config.Config, chainID string, logger log.Logger, ) (types.PrivValidator, error) { pvsc, err := tmgrpc.DialRemoteSigner( - config.PrivValidator, + cfg.PrivValidator, chainID, logger, - config.Instrumentation.Prometheus, + cfg.Instrumentation.Prometheus, ) if err != nil { return nil, fmt.Errorf("failed to start private validator: %w", err) @@ -1153,7 +1155,7 @@ func createAndStartPrivValidatorGRPCClient( return pvsc, nil } -func getRouterConfig(conf *cfg.Config, proxyApp proxy.AppConns) p2p.RouterOptions { +func getRouterConfig(conf *config.Config, proxyApp proxy.AppConns) p2p.RouterOptions { opts := p2p.RouterOptions{ QueueType: conf.P2P.QueueType, } diff --git a/node/node_test.go b/node/node_test.go index aae7f8008..a940fef54 100644 --- a/node/node_test.go +++ b/node/node_test.go @@ -13,12 +13,11 @@ import ( "github.com/stretchr/testify/assert" "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" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" "github.com/tendermint/tendermint/crypto/tmhash" @@ -38,12 +37,12 @@ import ( ) func TestNodeStartStop(t *testing.T) { - config := cfg.ResetTestRoot("node_node_test") + cfg := config.ResetTestRoot("node_node_test") - defer os.RemoveAll(config.RootDir) + defer os.RemoveAll(cfg.RootDir) // create & start node - ns, err := newDefaultNode(config, log.TestingLogger()) + ns, err := newDefaultNode(cfg, log.TestingLogger()) require.NoError(t, err) require.NoError(t, ns.Start()) @@ -81,7 +80,7 @@ func TestNodeStartStop(t *testing.T) { } } -func getTestNode(t *testing.T, conf *cfg.Config, logger log.Logger) *nodeImpl { +func getTestNode(t *testing.T, conf *config.Config, logger log.Logger) *nodeImpl { t.Helper() ns, err := newDefaultNode(conf, logger) require.NoError(t, err) @@ -92,12 +91,12 @@ func getTestNode(t *testing.T, conf *cfg.Config, logger log.Logger) *nodeImpl { } func TestNodeDelayedStart(t *testing.T) { - config := cfg.ResetTestRoot("node_delayed_start_test") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("node_delayed_start_test") + defer os.RemoveAll(cfg.RootDir) now := tmtime.Now() // create & start node - n := getTestNode(t, config, log.TestingLogger()) + n := getTestNode(t, cfg, log.TestingLogger()) n.GenesisDoc().GenesisTime = now.Add(2 * time.Second) require.NoError(t, n.Start()) @@ -108,11 +107,11 @@ func TestNodeDelayedStart(t *testing.T) { } func TestNodeSetAppVersion(t *testing.T) { - config := cfg.ResetTestRoot("node_app_version_test") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("node_app_version_test") + defer os.RemoveAll(cfg.RootDir) // create node - n := getTestNode(t, config, log.TestingLogger()) + n := getTestNode(t, cfg, log.TestingLogger()) // default config uses the kvstore app var appVersion uint64 = kvstore.ProtocolVersion @@ -129,9 +128,9 @@ func TestNodeSetAppVersion(t *testing.T) { func TestNodeSetPrivValTCP(t *testing.T) { addr := "tcp://" + testFreeAddr(t) - config := cfg.ResetTestRoot("node_priv_val_tcp_test") - defer os.RemoveAll(config.RootDir) - config.PrivValidator.ListenAddr = addr + cfg := config.ResetTestRoot("node_priv_val_tcp_test") + defer os.RemoveAll(cfg.RootDir) + cfg.PrivValidator.ListenAddr = addr dialer := privval.DialTCPFn(addr, 100*time.Millisecond, ed25519.GenPrivKey()) dialerEndpoint := privval.NewSignerDialerEndpoint( @@ -142,7 +141,7 @@ func TestNodeSetPrivValTCP(t *testing.T) { signerServer := privval.NewSignerServer( dialerEndpoint, - config.ChainID(), + cfg.ChainID(), types.NewMockPV(), ) @@ -154,7 +153,7 @@ func TestNodeSetPrivValTCP(t *testing.T) { }() defer signerServer.Stop() //nolint:errcheck // ignore for tests - n := getTestNode(t, config, log.TestingLogger()) + n := getTestNode(t, cfg, log.TestingLogger()) assert.IsType(t, &privval.RetrySignerClient{}, n.PrivValidator()) } @@ -162,11 +161,11 @@ func TestNodeSetPrivValTCP(t *testing.T) { func TestPrivValidatorListenAddrNoProtocol(t *testing.T) { addrNoPrefix := testFreeAddr(t) - config := cfg.ResetTestRoot("node_priv_val_tcp_test") - defer os.RemoveAll(config.RootDir) - config.PrivValidator.ListenAddr = addrNoPrefix + cfg := config.ResetTestRoot("node_priv_val_tcp_test") + defer os.RemoveAll(cfg.RootDir) + cfg.PrivValidator.ListenAddr = addrNoPrefix - _, err := newDefaultNode(config, log.TestingLogger()) + _, err := newDefaultNode(cfg, log.TestingLogger()) assert.Error(t, err) } @@ -174,9 +173,9 @@ func TestNodeSetPrivValIPC(t *testing.T) { tmpfile := "/tmp/kms." + tmrand.Str(6) + ".sock" defer os.Remove(tmpfile) // clean up - config := cfg.ResetTestRoot("node_priv_val_tcp_test") - defer os.RemoveAll(config.RootDir) - config.PrivValidator.ListenAddr = "unix://" + tmpfile + cfg := config.ResetTestRoot("node_priv_val_tcp_test") + defer os.RemoveAll(cfg.RootDir) + cfg.PrivValidator.ListenAddr = "unix://" + tmpfile dialer := privval.DialUnixFn(tmpfile) dialerEndpoint := privval.NewSignerDialerEndpoint( @@ -187,7 +186,7 @@ func TestNodeSetPrivValIPC(t *testing.T) { pvsc := privval.NewSignerServer( dialerEndpoint, - config.ChainID(), + cfg.ChainID(), types.NewMockPV(), ) @@ -196,7 +195,7 @@ func TestNodeSetPrivValIPC(t *testing.T) { require.NoError(t, err) }() defer pvsc.Stop() //nolint:errcheck // ignore for tests - n := getTestNode(t, config, log.TestingLogger()) + n := getTestNode(t, cfg, log.TestingLogger()) assert.IsType(t, &privval.RetrySignerClient{}, n.PrivValidator()) } @@ -212,8 +211,8 @@ func testFreeAddr(t *testing.T) string { // create a proposal block using real and full // mempool and evidence pool and validate it. func TestCreateProposalBlock(t *testing.T) { - config := cfg.ResetTestRoot("node_create_proposal") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("node_create_proposal") + defer os.RemoveAll(cfg.RootDir) cc := abciclient.NewLocalCreator(kvstore.NewApplication()) proxyApp := proxy.NewAppConns(cc) err := proxyApp.Start() @@ -233,7 +232,7 @@ func TestCreateProposalBlock(t *testing.T) { proposerAddr, _ := state.Validators.GetByIndex(0) mp := mempoolv0.NewCListMempool( - config.Mempool, + cfg.Mempool, proxyApp.Mempool(), state.LastBlockHeight, mempoolv0.WithMetrics(mempool.NopMetrics()), @@ -304,8 +303,8 @@ func TestCreateProposalBlock(t *testing.T) { } func TestMaxTxsProposalBlockSize(t *testing.T) { - config := cfg.ResetTestRoot("node_create_proposal") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("node_create_proposal") + defer os.RemoveAll(cfg.RootDir) cc := abciclient.NewLocalCreator(kvstore.NewApplication()) proxyApp := proxy.NewAppConns(cc) err := proxyApp.Start() @@ -325,7 +324,7 @@ func TestMaxTxsProposalBlockSize(t *testing.T) { // Make Mempool mp := mempoolv0.NewCListMempool( - config.Mempool, + cfg.Mempool, proxyApp.Mempool(), state.LastBlockHeight, mempoolv0.WithMetrics(mempool.NopMetrics()), @@ -366,8 +365,8 @@ func TestMaxTxsProposalBlockSize(t *testing.T) { } func TestMaxProposalBlockSize(t *testing.T) { - config := cfg.ResetTestRoot("node_create_proposal") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("node_create_proposal") + defer os.RemoveAll(cfg.RootDir) cc := abciclient.NewLocalCreator(kvstore.NewApplication()) proxyApp := proxy.NewAppConns(cc) err := proxyApp.Start() @@ -385,7 +384,7 @@ func TestMaxProposalBlockSize(t *testing.T) { // Make Mempool mp := mempoolv0.NewCListMempool( - config.Mempool, + cfg.Mempool, proxyApp.Mempool(), state.LastBlockHeight, mempoolv0.WithMetrics(mempool.NopMetrics()), @@ -481,17 +480,17 @@ func TestMaxProposalBlockSize(t *testing.T) { } func TestNodeNewSeedNode(t *testing.T) { - config := cfg.ResetTestRoot("node_new_node_custom_reactors_test") - config.Mode = cfg.ModeSeed - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("node_new_node_custom_reactors_test") + cfg.Mode = config.ModeSeed + defer os.RemoveAll(cfg.RootDir) - nodeKey, err := types.LoadOrGenNodeKey(config.NodeKeyFile()) + nodeKey, err := types.LoadOrGenNodeKey(cfg.NodeKeyFile()) require.NoError(t, err) - ns, err := makeSeedNode(config, - cfg.DefaultDBProvider, + ns, err := makeSeedNode(cfg, + config.DefaultDBProvider, nodeKey, - defaultGenesisDocProviderFunc(config), + defaultGenesisDocProviderFunc(cfg), log.TestingLogger(), ) require.NoError(t, err) @@ -505,68 +504,68 @@ func TestNodeNewSeedNode(t *testing.T) { } func TestNodeSetEventSink(t *testing.T) { - config := cfg.ResetTestRoot("node_app_version_test") - defer os.RemoveAll(config.RootDir) + cfg := config.ResetTestRoot("node_app_version_test") + defer os.RemoveAll(cfg.RootDir) logger := log.TestingLogger() - setupTest := func(t *testing.T, conf *cfg.Config) []indexer.EventSink { + setupTest := func(t *testing.T, conf *config.Config) []indexer.EventSink { eventBus, err := createAndStartEventBus(logger) require.NoError(t, err) - genDoc, err := types.GenesisDocFromFile(config.GenesisFile()) + genDoc, err := types.GenesisDocFromFile(cfg.GenesisFile()) require.NoError(t, err) - indexService, eventSinks, err := createAndStartIndexerService(config, - cfg.DefaultDBProvider, eventBus, logger, genDoc.ChainID) + indexService, eventSinks, err := createAndStartIndexerService(cfg, + config.DefaultDBProvider, eventBus, logger, genDoc.ChainID) require.NoError(t, err) t.Cleanup(func() { require.NoError(t, indexService.Stop()) }) return eventSinks } - eventSinks := setupTest(t, config) + eventSinks := setupTest(t, cfg) assert.Equal(t, 1, len(eventSinks)) assert.Equal(t, indexer.KV, eventSinks[0].Type()) - config.TxIndex.Indexer = []string{"null"} - eventSinks = setupTest(t, config) + cfg.TxIndex.Indexer = []string{"null"} + eventSinks = setupTest(t, cfg) assert.Equal(t, 1, len(eventSinks)) assert.Equal(t, indexer.NULL, eventSinks[0].Type()) - config.TxIndex.Indexer = []string{"null", "kv"} - eventSinks = setupTest(t, config) + cfg.TxIndex.Indexer = []string{"null", "kv"} + eventSinks = setupTest(t, cfg) assert.Equal(t, 1, len(eventSinks)) assert.Equal(t, indexer.NULL, eventSinks[0].Type()) - config.TxIndex.Indexer = []string{"kvv"} - ns, err := newDefaultNode(config, logger) + cfg.TxIndex.Indexer = []string{"kvv"} + ns, err := newDefaultNode(cfg, logger) assert.Nil(t, ns) assert.Equal(t, errors.New("unsupported event sink type"), err) - config.TxIndex.Indexer = []string{} - eventSinks = setupTest(t, config) + cfg.TxIndex.Indexer = []string{} + eventSinks = setupTest(t, cfg) assert.Equal(t, 1, len(eventSinks)) assert.Equal(t, indexer.NULL, eventSinks[0].Type()) - config.TxIndex.Indexer = []string{"psql"} - ns, err = newDefaultNode(config, logger) + cfg.TxIndex.Indexer = []string{"psql"} + ns, err = newDefaultNode(cfg, logger) assert.Nil(t, ns) assert.Equal(t, errors.New("the psql connection settings cannot be empty"), err) var psqlConn = "test" - config.TxIndex.Indexer = []string{"psql"} - config.TxIndex.PsqlConn = psqlConn - eventSinks = setupTest(t, config) + cfg.TxIndex.Indexer = []string{"psql"} + cfg.TxIndex.PsqlConn = psqlConn + eventSinks = setupTest(t, cfg) assert.Equal(t, 1, len(eventSinks)) assert.Equal(t, indexer.PSQL, eventSinks[0].Type()) - config.TxIndex.Indexer = []string{"psql", "kv"} - config.TxIndex.PsqlConn = psqlConn - eventSinks = setupTest(t, config) + cfg.TxIndex.Indexer = []string{"psql", "kv"} + cfg.TxIndex.PsqlConn = psqlConn + eventSinks = setupTest(t, cfg) assert.Equal(t, 2, len(eventSinks)) // we use map to filter the duplicated sinks, so it's not guarantee the order when append sinks. @@ -577,9 +576,9 @@ func TestNodeSetEventSink(t *testing.T) { assert.Equal(t, indexer.KV, eventSinks[1].Type()) } - config.TxIndex.Indexer = []string{"kv", "psql"} - config.TxIndex.PsqlConn = psqlConn - eventSinks = setupTest(t, config) + cfg.TxIndex.Indexer = []string{"kv", "psql"} + cfg.TxIndex.PsqlConn = psqlConn + eventSinks = setupTest(t, cfg) assert.Equal(t, 2, len(eventSinks)) if eventSinks[0].Type() == indexer.KV { @@ -590,15 +589,15 @@ func TestNodeSetEventSink(t *testing.T) { } var e = errors.New("found duplicated sinks, please check the tx-index section in the config.toml") - config.TxIndex.Indexer = []string{"psql", "kv", "Kv"} - config.TxIndex.PsqlConn = psqlConn - _, err = newDefaultNode(config, logger) + cfg.TxIndex.Indexer = []string{"psql", "kv", "Kv"} + cfg.TxIndex.PsqlConn = psqlConn + _, err = newDefaultNode(cfg, logger) require.Error(t, err) assert.Equal(t, e, err) - config.TxIndex.Indexer = []string{"Psql", "kV", "kv", "pSql"} - config.TxIndex.PsqlConn = psqlConn - _, err = newDefaultNode(config, logger) + cfg.TxIndex.Indexer = []string{"Psql", "kV", "kv", "pSql"} + cfg.TxIndex.PsqlConn = psqlConn + _, err = newDefaultNode(cfg, logger) require.Error(t, err) assert.Equal(t, e, err) } @@ -648,13 +647,13 @@ func loadStatefromGenesis(t *testing.T) sm.State { stateDB := dbm.NewMemDB() stateStore := sm.NewStore(stateDB) - config := cfg.ResetTestRoot("load_state_from_genesis") + cfg := config.ResetTestRoot("load_state_from_genesis") loadedState, err := stateStore.Load() require.NoError(t, err) require.True(t, loadedState.IsEmpty()) - genDoc, _ := factory.RandGenesisDoc(config, 0, false, 10) + genDoc, _ := factory.RandGenesisDoc(cfg, 0, false, 10) state, err := loadStateFromDBOrGenesisDocProvider( stateStore, diff --git a/node/setup.go b/node/setup.go index 6d403b0b0..63fb4c739 100644 --- a/node/setup.go +++ b/node/setup.go @@ -7,18 +7,17 @@ import ( "fmt" "math" "net" - _ "net/http/pprof" // nolint: gosec // securely exposed on separate, optional port "time" 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/config" "github.com/tendermint/tendermint/crypto" bcv0 "github.com/tendermint/tendermint/internal/blocksync/v0" bcv2 "github.com/tendermint/tendermint/internal/blocksync/v2" - cs "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/consensus" "github.com/tendermint/tendermint/internal/evidence" "github.com/tendermint/tendermint/internal/mempool" mempoolv0 "github.com/tendermint/tendermint/internal/mempool/v0" @@ -37,17 +36,19 @@ import ( "github.com/tendermint/tendermint/store" "github.com/tendermint/tendermint/types" "github.com/tendermint/tendermint/version" + + _ "net/http/pprof" // nolint: gosec // securely exposed on separate, optional port ) -func initDBs(config *cfg.Config, dbProvider cfg.DBProvider) (blockStore *store.BlockStore, stateDB dbm.DB, err error) { +func initDBs(cfg *config.Config, dbProvider config.DBProvider) (blockStore *store.BlockStore, stateDB dbm.DB, err error) { //nolint:lll var blockStoreDB dbm.DB - blockStoreDB, err = dbProvider(&cfg.DBContext{ID: "blockstore", Config: config}) + blockStoreDB, err = dbProvider(&config.DBContext{ID: "blockstore", Config: cfg}) if err != nil { return } blockStore = store.NewBlockStore(blockStoreDB) - stateDB, err = dbProvider(&cfg.DBContext{ID: "state", Config: config}) + stateDB, err = dbProvider(&config.DBContext{ID: "state", Config: cfg}) return } @@ -70,13 +71,13 @@ func createAndStartEventBus(logger log.Logger) (*types.EventBus, error) { } func createAndStartIndexerService( - config *cfg.Config, - dbProvider cfg.DBProvider, + cfg *config.Config, + dbProvider config.DBProvider, eventBus *types.EventBus, logger log.Logger, chainID string, ) (*indexer.Service, []indexer.EventSink, error) { - eventSinks, err := sink.EventSinksFromConfig(config, dbProvider, chainID) + eventSinks, err := sink.EventSinksFromConfig(cfg, dbProvider, chainID) if err != nil { return nil, nil, err } @@ -100,7 +101,7 @@ func doHandshake( proxyApp proxy.AppConns, consensusLogger log.Logger) error { - handshaker := cs.NewHandshaker(stateStore, state, blockStore, genDoc) + handshaker := consensus.NewHandshaker(stateStore, state, blockStore, genDoc) handshaker.SetLogger(consensusLogger) handshaker.SetEventBus(eventBus) if err := handshaker.Handshake(proxyApp); err != nil { @@ -126,9 +127,9 @@ func logNodeStartupInfo(state sm.State, pubKey crypto.PubKey, logger, consensusL ) } switch { - case mode == cfg.ModeFull: + case mode == config.ModeFull: consensusLogger.Info("This node is a fullnode") - case mode == cfg.ModeValidator: + case mode == config.ModeValidator: addr := pubKey.Address() // Log whether this node is a validator or an observer if state.Validators.HasAddress(addr) { @@ -149,7 +150,7 @@ func onlyValidatorIsUs(state sm.State, pubKey crypto.PubKey) bool { } func createMempoolReactor( - config *cfg.Config, + cfg *config.Config, proxyApp proxy.AppConns, state sm.State, memplMetrics *mempool.Metrics, @@ -158,8 +159,8 @@ func createMempoolReactor( logger log.Logger, ) (*p2p.ReactorShim, service.Service, mempool.Mempool, error) { - logger = logger.With("module", "mempool", "version", config.Mempool.Version) - channelShims := mempoolv0.GetChannelShims(config.Mempool) + logger = logger.With("module", "mempool", "version", cfg.Mempool.Version) + channelShims := mempoolv0.GetChannelShims(cfg.Mempool) reactorShim := p2p.NewReactorShim(logger, "MempoolShim", channelShims) var ( @@ -167,7 +168,7 @@ func createMempoolReactor( peerUpdates *p2p.PeerUpdates ) - if config.P2P.UseLegacy { + if cfg.P2P.UseLegacy { channels = getChannelsFromShim(reactorShim) peerUpdates = reactorShim.PeerUpdates } else { @@ -175,10 +176,10 @@ func createMempoolReactor( peerUpdates = peerManager.Subscribe() } - switch config.Mempool.Version { - case cfg.MempoolV0: + switch cfg.Mempool.Version { + case config.MempoolV0: mp := mempoolv0.NewCListMempool( - config.Mempool, + cfg.Mempool, proxyApp.Mempool(), state.LastBlockHeight, mempoolv0.WithMetrics(memplMetrics), @@ -190,23 +191,23 @@ func createMempoolReactor( reactor := mempoolv0.NewReactor( logger, - config.Mempool, + cfg.Mempool, peerManager, mp, channels[mempool.MempoolChannel], peerUpdates, ) - if config.Consensus.WaitForTxs() { + if cfg.Consensus.WaitForTxs() { mp.EnableTxsAvailable() } return reactorShim, reactor, mp, nil - case cfg.MempoolV1: + case config.MempoolV1: mp := mempoolv1.NewTxMempool( logger, - config.Mempool, + cfg.Mempool, proxyApp.Mempool(), state.LastBlockHeight, mempoolv1.WithMetrics(memplMetrics), @@ -216,34 +217,34 @@ func createMempoolReactor( reactor := mempoolv1.NewReactor( logger, - config.Mempool, + cfg.Mempool, peerManager, mp, channels[mempool.MempoolChannel], peerUpdates, ) - if config.Consensus.WaitForTxs() { + if cfg.Consensus.WaitForTxs() { mp.EnableTxsAvailable() } return reactorShim, reactor, mp, nil default: - return nil, nil, nil, fmt.Errorf("unknown mempool version: %s", config.Mempool.Version) + return nil, nil, nil, fmt.Errorf("unknown mempool version: %s", cfg.Mempool.Version) } } func createEvidenceReactor( - config *cfg.Config, - dbProvider cfg.DBProvider, + cfg *config.Config, + dbProvider config.DBProvider, stateDB dbm.DB, blockStore *store.BlockStore, peerManager *p2p.PeerManager, router *p2p.Router, logger log.Logger, ) (*p2p.ReactorShim, *evidence.Reactor, *evidence.Pool, error) { - evidenceDB, err := dbProvider(&cfg.DBContext{ID: "evidence", Config: config}) + evidenceDB, err := dbProvider(&config.DBContext{ID: "evidence", Config: cfg}) if err != nil { return nil, nil, nil, err } @@ -261,7 +262,7 @@ func createEvidenceReactor( peerUpdates *p2p.PeerUpdates ) - if config.P2P.UseLegacy { + if cfg.P2P.UseLegacy { channels = getChannelsFromShim(reactorShim) peerUpdates = reactorShim.PeerUpdates } else { @@ -281,21 +282,21 @@ func createEvidenceReactor( func createBlockchainReactor( logger log.Logger, - config *cfg.Config, + cfg *config.Config, state sm.State, blockExec *sm.BlockExecutor, blockStore *store.BlockStore, - csReactor *cs.Reactor, + csReactor *consensus.Reactor, peerManager *p2p.PeerManager, router *p2p.Router, blockSync bool, - metrics *cs.Metrics, + metrics *consensus.Metrics, ) (*p2p.ReactorShim, service.Service, error) { logger = logger.With("module", "blockchain") - switch config.BlockSync.Version { - case cfg.BlockSyncV0: + switch cfg.BlockSync.Version { + case config.BlockSyncV0: reactorShim := p2p.NewReactorShim(logger, "BlockchainShim", bcv0.ChannelShims) var ( @@ -303,7 +304,7 @@ func createBlockchainReactor( peerUpdates *p2p.PeerUpdates ) - if config.P2P.UseLegacy { + if cfg.P2P.UseLegacy { channels = getChannelsFromShim(reactorShim) peerUpdates = reactorShim.PeerUpdates } else { @@ -322,69 +323,69 @@ func createBlockchainReactor( return reactorShim, reactor, nil - case cfg.BlockSyncV2: + case config.BlockSyncV2: return nil, nil, errors.New("block sync version v2 is no longer supported. Please use v0") default: - return nil, nil, fmt.Errorf("unknown block sync version %s", config.BlockSync.Version) + return nil, nil, fmt.Errorf("unknown block sync version %s", cfg.BlockSync.Version) } } func createConsensusReactor( - config *cfg.Config, + cfg *config.Config, state sm.State, blockExec *sm.BlockExecutor, blockStore sm.BlockStore, mp mempool.Mempool, evidencePool *evidence.Pool, privValidator types.PrivValidator, - csMetrics *cs.Metrics, + csMetrics *consensus.Metrics, waitSync bool, eventBus *types.EventBus, peerManager *p2p.PeerManager, router *p2p.Router, logger log.Logger, -) (*p2p.ReactorShim, *cs.Reactor, *cs.State) { +) (*p2p.ReactorShim, *consensus.Reactor, *consensus.State) { - consensusState := cs.NewState( - config.Consensus, + consensusState := consensus.NewState( + cfg.Consensus, state.Copy(), blockExec, blockStore, mp, evidencePool, - cs.StateMetrics(csMetrics), + consensus.StateMetrics(csMetrics), ) consensusState.SetLogger(logger) - if privValidator != nil && config.Mode == cfg.ModeValidator { + if privValidator != nil && cfg.Mode == config.ModeValidator { consensusState.SetPrivValidator(privValidator) } - reactorShim := p2p.NewReactorShim(logger, "ConsensusShim", cs.ChannelShims) + reactorShim := p2p.NewReactorShim(logger, "ConsensusShim", consensus.ChannelShims) var ( channels map[p2p.ChannelID]*p2p.Channel peerUpdates *p2p.PeerUpdates ) - if config.P2P.UseLegacy { + if cfg.P2P.UseLegacy { channels = getChannelsFromShim(reactorShim) peerUpdates = reactorShim.PeerUpdates } else { - channels = makeChannelsFromShims(router, cs.ChannelShims) + channels = makeChannelsFromShims(router, consensus.ChannelShims) peerUpdates = peerManager.Subscribe() } - reactor := cs.NewReactor( + reactor := consensus.NewReactor( logger, consensusState, - channels[cs.StateChannel], - channels[cs.DataChannel], - channels[cs.VoteChannel], - channels[cs.VoteSetBitsChannel], + channels[consensus.StateChannel], + channels[consensus.DataChannel], + channels[consensus.VoteChannel], + channels[consensus.VoteSetBitsChannel], peerUpdates, waitSync, - cs.ReactorMetrics(csMetrics), + consensus.ReactorMetrics(csMetrics), ) // Services which will be publishing and/or subscribing for messages (events) @@ -394,20 +395,20 @@ func createConsensusReactor( return reactorShim, reactor, consensusState } -func createTransport(logger log.Logger, config *cfg.Config) *p2p.MConnTransport { +func createTransport(logger log.Logger, cfg *config.Config) *p2p.MConnTransport { return p2p.NewMConnTransport( - logger, p2p.MConnConfig(config.P2P), []*p2p.ChannelDescriptor{}, + logger, p2p.MConnConfig(cfg.P2P), []*p2p.ChannelDescriptor{}, p2p.MConnTransportOptions{ - MaxAcceptedConnections: uint32(config.P2P.MaxNumInboundPeers + - len(tmstrings.SplitAndTrimEmpty(config.P2P.UnconditionalPeerIDs, ",", " ")), + MaxAcceptedConnections: uint32(cfg.P2P.MaxNumInboundPeers + + len(tmstrings.SplitAndTrimEmpty(cfg.P2P.UnconditionalPeerIDs, ",", " ")), ), }, ) } func createPeerManager( - config *cfg.Config, - dbProvider cfg.DBProvider, + cfg *config.Config, + dbProvider config.DBProvider, p2pLogger log.Logger, nodeID types.NodeID, ) (*p2p.PeerManager, error) { @@ -415,16 +416,16 @@ func createPeerManager( var maxConns uint16 switch { - case config.P2P.MaxConnections > 0: - maxConns = config.P2P.MaxConnections + case cfg.P2P.MaxConnections > 0: + maxConns = cfg.P2P.MaxConnections - case config.P2P.MaxNumInboundPeers > 0 && config.P2P.MaxNumOutboundPeers > 0: - x := config.P2P.MaxNumInboundPeers + config.P2P.MaxNumOutboundPeers + case cfg.P2P.MaxNumInboundPeers > 0 && cfg.P2P.MaxNumOutboundPeers > 0: + x := cfg.P2P.MaxNumInboundPeers + cfg.P2P.MaxNumOutboundPeers if x > math.MaxUint16 { return nil, fmt.Errorf( "max inbound peers (%d) + max outbound peers (%d) exceeds maximum (%d)", - config.P2P.MaxNumInboundPeers, - config.P2P.MaxNumOutboundPeers, + cfg.P2P.MaxNumInboundPeers, + cfg.P2P.MaxNumOutboundPeers, math.MaxUint16, ) } @@ -436,7 +437,7 @@ func createPeerManager( } privatePeerIDs := make(map[types.NodeID]struct{}) - for _, id := range tmstrings.SplitAndTrimEmpty(config.P2P.PrivatePeerIDs, ",", " ") { + for _, id := range tmstrings.SplitAndTrimEmpty(cfg.P2P.PrivatePeerIDs, ",", " ") { privatePeerIDs[types.NodeID(id)] = struct{}{} } @@ -452,7 +453,7 @@ func createPeerManager( } peers := []p2p.NodeAddress{} - for _, p := range tmstrings.SplitAndTrimEmpty(config.P2P.PersistentPeers, ",", " ") { + for _, p := range tmstrings.SplitAndTrimEmpty(cfg.P2P.PersistentPeers, ",", " ") { address, err := p2p.ParseNodeAddress(p) if err != nil { return nil, fmt.Errorf("invalid peer address %q: %w", p, err) @@ -462,7 +463,7 @@ func createPeerManager( options.PersistentPeers = append(options.PersistentPeers, address.NodeID) } - for _, p := range tmstrings.SplitAndTrimEmpty(config.P2P.BootstrapPeers, ",", " ") { + for _, p := range tmstrings.SplitAndTrimEmpty(cfg.P2P.BootstrapPeers, ",", " ") { address, err := p2p.ParseNodeAddress(p) if err != nil { return nil, fmt.Errorf("invalid peer address %q: %w", p, err) @@ -470,7 +471,7 @@ func createPeerManager( peers = append(peers, address) } - peerDB, err := dbProvider(&cfg.DBContext{ID: "peerstore", Config: config}) + peerDB, err := dbProvider(&config.DBContext{ID: "peerstore", Config: cfg}) if err != nil { return nil, err } @@ -511,7 +512,7 @@ func createRouter( } func createSwitch( - config *cfg.Config, + cfg *config.Config, transport p2p.Transport, p2pMetrics *p2p.Metrics, mempoolReactor *p2p.ReactorShim, @@ -530,13 +531,13 @@ func createSwitch( peerFilters = []p2p.PeerFilterFunc{} ) - if !config.P2P.AllowDuplicateIP { + if !cfg.P2P.AllowDuplicateIP { connFilters = append(connFilters, p2p.ConnDuplicateIPFilter) } // Filter peers by addr or pubkey with an ABCI query. // If the query return code is OK, add peer. - if config.FilterPeers { + if cfg.FilterPeers { connFilters = append( connFilters, // ABCI query for address filtering. @@ -575,7 +576,7 @@ func createSwitch( } sw := p2p.NewSwitch( - config.P2P, + cfg.P2P, transport, p2p.WithMetrics(p2pMetrics), p2p.SwitchPeerFilters(peerFilters...), @@ -583,7 +584,7 @@ func createSwitch( ) sw.SetLogger(p2pLogger) - if config.Mode != cfg.ModeSeed { + if cfg.Mode != config.ModeSeed { sw.AddReactor("MEMPOOL", mempoolReactor) sw.AddReactor("BLOCKCHAIN", bcReactor) sw.AddReactor("CONSENSUS", consensusReactor) @@ -594,26 +595,26 @@ func createSwitch( sw.SetNodeInfo(nodeInfo) sw.SetNodeKey(nodeKey) - p2pLogger.Info("P2P Node ID", "ID", nodeKey.ID, "file", config.NodeKeyFile()) + p2pLogger.Info("P2P Node ID", "ID", nodeKey.ID, "file", cfg.NodeKeyFile()) return sw } -func createAddrBookAndSetOnSwitch(config *cfg.Config, sw *p2p.Switch, +func createAddrBookAndSetOnSwitch(cfg *config.Config, sw *p2p.Switch, p2pLogger log.Logger, nodeKey types.NodeKey) (pex.AddrBook, error) { - addrBook := pex.NewAddrBook(config.P2P.AddrBookFile(), config.P2P.AddrBookStrict) - addrBook.SetLogger(p2pLogger.With("book", config.P2P.AddrBookFile())) + addrBook := pex.NewAddrBook(cfg.P2P.AddrBookFile(), cfg.P2P.AddrBookStrict) + addrBook.SetLogger(p2pLogger.With("book", cfg.P2P.AddrBookFile())) // Add ourselves to addrbook to prevent dialing ourselves - if config.P2P.ExternalAddress != "" { - addr, err := types.NewNetAddressString(nodeKey.ID.AddressString(config.P2P.ExternalAddress)) + if cfg.P2P.ExternalAddress != "" { + addr, err := types.NewNetAddressString(nodeKey.ID.AddressString(cfg.P2P.ExternalAddress)) if err != nil { return nil, fmt.Errorf("p2p.external_address is incorrect: %w", err) } addrBook.AddOurAddress(addr) } - if config.P2P.ListenAddress != "" { - addr, err := types.NewNetAddressString(nodeKey.ID.AddressString(config.P2P.ListenAddress)) + if cfg.P2P.ListenAddress != "" { + addr, err := types.NewNetAddressString(nodeKey.ID.AddressString(cfg.P2P.ListenAddress)) if err != nil { return nil, fmt.Errorf("p2p.laddr is incorrect: %w", err) } @@ -625,19 +626,19 @@ func createAddrBookAndSetOnSwitch(config *cfg.Config, sw *p2p.Switch, return addrBook, nil } -func createPEXReactorAndAddToSwitch(addrBook pex.AddrBook, config *cfg.Config, +func createPEXReactorAndAddToSwitch(addrBook pex.AddrBook, cfg *config.Config, sw *p2p.Switch, logger log.Logger) *pex.Reactor { reactorConfig := &pex.ReactorConfig{ - Seeds: tmstrings.SplitAndTrimEmpty(config.P2P.Seeds, ",", " "), - SeedMode: config.Mode == cfg.ModeSeed, + Seeds: tmstrings.SplitAndTrimEmpty(cfg.P2P.Seeds, ",", " "), + SeedMode: cfg.Mode == config.ModeSeed, // See consensus/reactor.go: blocksToContributeToBecomeGoodPeer 10000 // blocks assuming 10s blocks ~ 28 hours. // TODO (melekes): make it dynamic based on the actual block latencies // from the live network. // https://github.com/tendermint/tendermint/issues/3523 SeedDisconnectWaitPeriod: 28 * time.Hour, - PersistentPeersMaxDialPeriod: config.P2P.PersistentPeersMaxDialPeriod, + PersistentPeersMaxDialPeriod: cfg.P2P.PersistentPeersMaxDialPeriod, } // TODO persistent peers ? so we can have their DNS addrs saved pexReactor := pex.NewReactor(addrBook, reactorConfig) @@ -647,7 +648,7 @@ func createPEXReactorAndAddToSwitch(addrBook pex.AddrBook, config *cfg.Config, } func createPEXReactorV2( - config *cfg.Config, + cfg *config.Config, logger log.Logger, peerManager *p2p.PeerManager, router *p2p.Router, @@ -663,7 +664,7 @@ func createPEXReactorV2( } func makeNodeInfo( - config *cfg.Config, + cfg *config.Config, nodeKey types.NodeKey, eventSinks []indexer.EventSink, genDoc *types.GenesisDoc, @@ -676,15 +677,15 @@ func makeNodeInfo( } var bcChannel byte - switch config.BlockSync.Version { - case cfg.BlockSyncV0: + switch cfg.BlockSync.Version { + case config.BlockSyncV0: bcChannel = byte(bcv0.BlockSyncChannel) - case cfg.BlockSyncV2: + case config.BlockSyncV2: bcChannel = bcv2.BlockchainChannel default: - return types.NodeInfo{}, fmt.Errorf("unknown blocksync version %s", config.BlockSync.Version) + return types.NodeInfo{}, fmt.Errorf("unknown blocksync version %s", cfg.BlockSync.Version) } nodeInfo := types.NodeInfo{ @@ -698,10 +699,10 @@ func makeNodeInfo( Version: version.TMVersion, Channels: []byte{ bcChannel, - byte(cs.StateChannel), - byte(cs.DataChannel), - byte(cs.VoteChannel), - byte(cs.VoteSetBitsChannel), + byte(consensus.StateChannel), + byte(consensus.DataChannel), + byte(consensus.VoteChannel), + byte(consensus.VoteSetBitsChannel), byte(mempool.MempoolChannel), byte(evidence.EvidenceChannel), byte(statesync.SnapshotChannel), @@ -709,21 +710,21 @@ func makeNodeInfo( byte(statesync.LightBlockChannel), byte(statesync.ParamsChannel), }, - Moniker: config.Moniker, + Moniker: cfg.Moniker, Other: types.NodeInfoOther{ TxIndex: txIndexerStatus, - RPCAddress: config.RPC.ListenAddress, + RPCAddress: cfg.RPC.ListenAddress, }, } - if config.P2P.PexReactor { + if cfg.P2P.PexReactor { nodeInfo.Channels = append(nodeInfo.Channels, pex.PexChannel) } - lAddr := config.P2P.ExternalAddress + lAddr := cfg.P2P.ExternalAddress if lAddr == "" { - lAddr = config.P2P.ListenAddress + lAddr = cfg.P2P.ListenAddress } nodeInfo.ListenAddr = lAddr @@ -733,7 +734,7 @@ func makeNodeInfo( } func makeSeedNodeInfo( - config *cfg.Config, + cfg *config.Config, nodeKey types.NodeKey, genDoc *types.GenesisDoc, state sm.State, @@ -748,21 +749,21 @@ func makeSeedNodeInfo( Network: genDoc.ChainID, Version: version.TMVersion, Channels: []byte{}, - Moniker: config.Moniker, + Moniker: cfg.Moniker, Other: types.NodeInfoOther{ TxIndex: "off", - RPCAddress: config.RPC.ListenAddress, + RPCAddress: cfg.RPC.ListenAddress, }, } - if config.P2P.PexReactor { + if cfg.P2P.PexReactor { nodeInfo.Channels = append(nodeInfo.Channels, pex.PexChannel) } - lAddr := config.P2P.ExternalAddress + lAddr := cfg.P2P.ExternalAddress if lAddr == "" { - lAddr = config.P2P.ListenAddress + lAddr = cfg.P2P.ListenAddress } nodeInfo.ListenAddr = lAddr diff --git a/privval/grpc/client.go b/privval/grpc/client.go index 77f3930aa..f4c0b7d99 100644 --- a/privval/grpc/client.go +++ b/privval/grpc/client.go @@ -7,7 +7,7 @@ import ( "google.golang.org/grpc/status" "github.com/tendermint/tendermint/crypto" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/libs/log" privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" @@ -62,7 +62,7 @@ func (sc *SignerClient) GetPubKey(ctx context.Context) (crypto.PubKey, error) { return nil, errStatus.Err() } - pk, err := cryptoenc.PubKeyFromProto(resp.PubKey) + pk, err := encoding.PubKeyFromProto(resp.PubKey) if err != nil { return nil, err } diff --git a/privval/grpc/server.go b/privval/grpc/server.go index f5c434b1b..13e0c9073 100644 --- a/privval/grpc/server.go +++ b/privval/grpc/server.go @@ -7,7 +7,7 @@ import ( "google.golang.org/grpc/status" "github.com/tendermint/tendermint/crypto" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/libs/log" privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval" "github.com/tendermint/tendermint/types" @@ -44,7 +44,7 @@ func (ss *SignerServer) GetPubKey(ctx context.Context, req *privvalproto.PubKeyR return nil, status.Errorf(codes.NotFound, "error getting pubkey: %v", err) } - pk, err := cryptoenc.PubKeyToProto(pubKey) + pk, err := encoding.PubKeyToProto(pubKey) if err != nil { return nil, status.Errorf(codes.Internal, "error transitioning pubkey to proto: %v", err) } diff --git a/privval/grpc/util.go b/privval/grpc/util.go index 62647542c..413acca8e 100644 --- a/privval/grpc/util.go +++ b/privval/grpc/util.go @@ -11,7 +11,7 @@ import ( grpc_retry "github.com/grpc-ecosystem/go-grpc-middleware/retry" grpc_prometheus "github.com/grpc-ecosystem/go-grpc-prometheus" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/libs/log" tmnet "github.com/tendermint/tendermint/libs/net" grpc "google.golang.org/grpc" @@ -88,15 +88,15 @@ func GenerateTLS(certPath, keyPath, ca string, log log.Logger) grpc.DialOption { // DialRemoteSigner is a generalized function to dial the gRPC server. func DialRemoteSigner( - config *cfg.PrivValidatorConfig, + cfg *config.PrivValidatorConfig, chainID string, logger log.Logger, usePrometheus bool, ) (*SignerClient, error) { var transportSecurity grpc.DialOption - if config.AreSecurityOptionsPresent() { - transportSecurity = GenerateTLS(config.ClientCertificateFile(), - config.ClientKeyFile(), config.RootCAFile(), logger) + if cfg.AreSecurityOptionsPresent() { + transportSecurity = GenerateTLS(cfg.ClientCertificateFile(), + cfg.ClientKeyFile(), cfg.RootCAFile(), logger) } else { transportSecurity = grpc.WithInsecure() logger.Info("Using an insecure gRPC connection!") @@ -111,7 +111,7 @@ func DialRemoteSigner( dialOptions = append(dialOptions, transportSecurity) ctx := context.Background() - _, address := tmnet.ProtocolAndAddress(config.ListenAddr) + _, address := tmnet.ProtocolAndAddress(cfg.ListenAddr) conn, err := grpc.DialContext(ctx, address, dialOptions...) if err != nil { logger.Error("unable to connect to server", "target", address, "err", err) diff --git a/privval/msgs_test.go b/privval/msgs_test.go index bf532bd7b..7ac9f2c5d 100644 --- a/privval/msgs_test.go +++ b/privval/msgs_test.go @@ -10,7 +10,7 @@ import ( "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/crypto/tmhash" cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto" privproto "github.com/tendermint/tendermint/proto/tendermint/privval" @@ -60,7 +60,7 @@ func exampleProposal() *types.Proposal { // nolint:lll // ignore line length for tests func TestPrivvalVectors(t *testing.T) { pk := ed25519.GenPrivKeyFromSecret([]byte("it's a secret")).PubKey() - ppk, err := cryptoenc.PubKeyToProto(pk) + ppk, err := encoding.PubKeyToProto(pk) require.NoError(t, err) // Generate a simple vote diff --git a/privval/secret_connection.go b/privval/secret_connection.go index 8847f91db..ffa5d36ed 100644 --- a/privval/secret_connection.go +++ b/privval/secret_connection.go @@ -23,7 +23,7 @@ import ( "github.com/tendermint/tendermint/crypto" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/internal/libs/protoio" tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/libs/async" @@ -408,7 +408,7 @@ func shareAuthSignature(sc io.ReadWriter, pubKey crypto.PubKey, signature []byte // Send our info and receive theirs in tandem. var trs, _ = async.Parallel( func(_ int) (val interface{}, abort bool, err error) { - pbpk, err := cryptoenc.PubKeyToProto(pubKey) + pbpk, err := encoding.PubKeyToProto(pubKey) if err != nil { return nil, true, err } @@ -425,7 +425,7 @@ func shareAuthSignature(sc io.ReadWriter, pubKey crypto.PubKey, signature []byte return nil, true, err // abort } - pk, err := cryptoenc.PubKeyFromProto(pba.PubKey) + pk, err := encoding.PubKeyFromProto(pba.PubKey) if err != nil { return nil, true, err // abort } diff --git a/privval/signer_client.go b/privval/signer_client.go index d25584c8f..5e5b32a92 100644 --- a/privval/signer_client.go +++ b/privval/signer_client.go @@ -6,7 +6,7 @@ import ( "time" "github.com/tendermint/tendermint/crypto" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" "github.com/tendermint/tendermint/types" @@ -83,7 +83,7 @@ func (sc *SignerClient) GetPubKey(ctx context.Context) (crypto.PubKey, error) { return nil, &RemoteSignerError{Code: int(resp.Error.Code), Description: resp.Error.Description} } - pk, err := cryptoenc.PubKeyFromProto(resp.PubKey) + pk, err := encoding.PubKeyFromProto(resp.PubKey) if err != nil { return nil, err } diff --git a/privval/signer_requestHandler.go b/privval/signer_requestHandler.go index 18ad8a996..d07c65620 100644 --- a/privval/signer_requestHandler.go +++ b/privval/signer_requestHandler.go @@ -5,7 +5,7 @@ import ( "fmt" "github.com/tendermint/tendermint/crypto" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" cryptoproto "github.com/tendermint/tendermint/proto/tendermint/crypto" privvalproto "github.com/tendermint/tendermint/proto/tendermint/privval" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" @@ -37,7 +37,7 @@ func DefaultValidationRequestHandler( if err != nil { return res, err } - pk, err := cryptoenc.PubKeyToProto(pubKey) + pk, err := encoding.PubKeyToProto(pubKey) if err != nil { return res, err } diff --git a/proto/tendermint/blocksync/message.go b/proto/tendermint/blocksync/message.go index d448ccc4b..1840c4e61 100644 --- a/proto/tendermint/blocksync/message.go +++ b/proto/tendermint/blocksync/message.go @@ -2,9 +2,9 @@ package blocksync import ( "errors" - fmt "fmt" + "fmt" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" ) const ( diff --git a/proto/tendermint/blocksync/message_test.go b/proto/tendermint/blocksync/message_test.go index dd1aebbd0..f81de149f 100644 --- a/proto/tendermint/blocksync/message_test.go +++ b/proto/tendermint/blocksync/message_test.go @@ -5,7 +5,7 @@ import ( math "math" "testing" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" "github.com/stretchr/testify/require" bcproto "github.com/tendermint/tendermint/proto/tendermint/blocksync" diff --git a/proto/tendermint/consensus/message.go b/proto/tendermint/consensus/message.go index 51feffc22..bcdab629a 100644 --- a/proto/tendermint/consensus/message.go +++ b/proto/tendermint/consensus/message.go @@ -1,9 +1,9 @@ package consensus import ( - fmt "fmt" + "fmt" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" ) // Wrap implements the p2p Wrapper interface and wraps a consensus proto message. diff --git a/proto/tendermint/mempool/message.go b/proto/tendermint/mempool/message.go index 64a79bc81..a3e249f99 100644 --- a/proto/tendermint/mempool/message.go +++ b/proto/tendermint/mempool/message.go @@ -1,9 +1,9 @@ package mempool import ( - fmt "fmt" + "fmt" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" ) // Wrap implements the p2p Wrapper interface and wraps a mempool message. diff --git a/proto/tendermint/p2p/pex.go b/proto/tendermint/p2p/pex.go index 8ba8cd2b2..38c8239dd 100644 --- a/proto/tendermint/p2p/pex.go +++ b/proto/tendermint/p2p/pex.go @@ -1,9 +1,9 @@ package p2p import ( - fmt "fmt" + "fmt" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" ) // Wrap implements the p2p Wrapper interface and wraps a PEX message. diff --git a/proto/tendermint/statesync/message.go b/proto/tendermint/statesync/message.go index 992cd7525..92d3764fd 100644 --- a/proto/tendermint/statesync/message.go +++ b/proto/tendermint/statesync/message.go @@ -2,9 +2,9 @@ package statesync import ( "errors" - fmt "fmt" + "fmt" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" ) // Wrap implements the p2p Wrapper interface and wraps a state sync proto message. diff --git a/proto/tendermint/statesync/message_test.go b/proto/tendermint/statesync/message_test.go index 40428ec07..cccd25766 100644 --- a/proto/tendermint/statesync/message_test.go +++ b/proto/tendermint/statesync/message_test.go @@ -4,7 +4,7 @@ import ( "encoding/hex" "testing" - proto "github.com/gogo/protobuf/proto" + "github.com/gogo/protobuf/proto" "github.com/stretchr/testify/require" ssproto "github.com/tendermint/tendermint/proto/tendermint/statesync" diff --git a/rpc/client/event_test.go b/rpc/client/event_test.go index e5d2c35f3..54d19a201 100644 --- a/rpc/client/event_test.go +++ b/rpc/client/event_test.go @@ -13,7 +13,7 @@ import ( abci "github.com/tendermint/tendermint/abci/types" tmrand "github.com/tendermint/tendermint/libs/rand" "github.com/tendermint/tendermint/rpc/client" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" "github.com/tendermint/tendermint/types" ) @@ -127,7 +127,7 @@ func testTxEventsSent(t *testing.T, broadcastMethod string) { // send go func() { var ( - txres *ctypes.ResultBroadcastTx + txres *coretypes.ResultBroadcastTx err error ctx = context.Background() ) diff --git a/rpc/client/evidence_test.go b/rpc/client/evidence_test.go index 5626b7f48..98b071b91 100644 --- a/rpc/client/evidence_test.go +++ b/rpc/client/evidence_test.go @@ -11,7 +11,7 @@ import ( abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/crypto/ed25519" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" "github.com/tendermint/tendermint/crypto/tmhash" tmrand "github.com/tendermint/tendermint/libs/rand" "github.com/tendermint/tendermint/privval" @@ -150,7 +150,7 @@ func TestBroadcastEvidence_DuplicateVoteEvidence(t *testing.T) { err = abci.ReadMessage(bytes.NewReader(qres.Value), &v) require.NoError(t, err, "Error reading query result, value %v", qres.Value) - pk, err := cryptoenc.PubKeyFromProto(v.PubKey) + pk, err := encoding.PubKeyFromProto(v.PubKey) require.NoError(t, err) require.EqualValues(t, rawpub, pk, "Stored PubKey not equal with expected, value %v", string(qres.Value)) diff --git a/rpc/client/examples_test.go b/rpc/client/examples_test.go index e241404f3..1acc29c11 100644 --- a/rpc/client/examples_test.go +++ b/rpc/client/examples_test.go @@ -8,7 +8,7 @@ import ( "github.com/tendermint/tendermint/abci/example/kvstore" rpchttp "github.com/tendermint/tendermint/rpc/client/http" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" rpctest "github.com/tendermint/tendermint/rpc/test" ) @@ -138,7 +138,7 @@ func ExampleHTTP_batching() { // Each result in the returned list is the deserialized result of each // respective ABCIQuery response for _, result := range results { - qr, ok := result.(*ctypes.ResultABCIQuery) + qr, ok := result.(*coretypes.ResultABCIQuery) if !ok { log.Fatal("invalid result type from ABCIQuery request") } diff --git a/rpc/client/helpers_test.go b/rpc/client/helpers_test.go index 6d2c2883d..60732b991 100644 --- a/rpc/client/helpers_test.go +++ b/rpc/client/helpers_test.go @@ -10,7 +10,7 @@ import ( "github.com/tendermint/tendermint/rpc/client" "github.com/tendermint/tendermint/rpc/client/mock" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" ) func TestWaitForHeight(t *testing.T) { @@ -33,7 +33,7 @@ func TestWaitForHeight(t *testing.T) { // now set current block height to 10 m.Call = mock.Call{ - Response: &ctypes.ResultStatus{SyncInfo: ctypes.SyncInfo{LatestBlockHeight: 10}}, + Response: &coretypes.ResultStatus{SyncInfo: coretypes.SyncInfo{LatestBlockHeight: 10}}, } // we will not wait for more than 10 blocks @@ -53,7 +53,7 @@ func TestWaitForHeight(t *testing.T) { // we use the callback to update the status height myWaiter := func(delta int64) error { // update the height for the next call - m.Call.Response = &ctypes.ResultStatus{SyncInfo: ctypes.SyncInfo{LatestBlockHeight: 15}} + m.Call.Response = &coretypes.ResultStatus{SyncInfo: coretypes.SyncInfo{LatestBlockHeight: 15}} return client.DefaultWaitStrategy(delta) } @@ -65,13 +65,13 @@ func TestWaitForHeight(t *testing.T) { pre := r.Calls[3] require.Nil(pre.Error) - prer, ok := pre.Response.(*ctypes.ResultStatus) + prer, ok := pre.Response.(*coretypes.ResultStatus) require.True(ok) assert.Equal(int64(10), prer.SyncInfo.LatestBlockHeight) post := r.Calls[4] require.Nil(post.Error) - postr, ok := post.Response.(*ctypes.ResultStatus) + postr, ok := post.Response.(*coretypes.ResultStatus) require.True(ok) assert.Equal(int64(15), postr.SyncInfo.LatestBlockHeight) } diff --git a/rpc/client/http/http.go b/rpc/client/http/http.go index c3a0f379b..65d0f434b 100644 --- a/rpc/client/http/http.go +++ b/rpc/client/http/http.go @@ -7,7 +7,7 @@ import ( "github.com/tendermint/tendermint/libs/bytes" rpcclient "github.com/tendermint/tendermint/rpc/client" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" jsonrpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client" "github.com/tendermint/tendermint/types" ) @@ -198,8 +198,8 @@ func (b *BatchHTTP) Count() int { //----------------------------------------------------------------------------- // baseRPCClient -func (c *baseRPCClient) Status(ctx context.Context) (*ctypes.ResultStatus, error) { - result := new(ctypes.ResultStatus) +func (c *baseRPCClient) Status(ctx context.Context) (*coretypes.ResultStatus, error) { + result := new(coretypes.ResultStatus) _, err := c.caller.Call(ctx, "status", map[string]interface{}{}, result) if err != nil { return nil, err @@ -208,8 +208,8 @@ func (c *baseRPCClient) Status(ctx context.Context) (*ctypes.ResultStatus, error return result, nil } -func (c *baseRPCClient) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) { - result := new(ctypes.ResultABCIInfo) +func (c *baseRPCClient) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { + result := new(coretypes.ResultABCIInfo) _, err := c.caller.Call(ctx, "abci_info", map[string]interface{}{}, result) if err != nil { return nil, err @@ -222,7 +222,7 @@ func (c *baseRPCClient) ABCIQuery( ctx context.Context, path string, data bytes.HexBytes, -) (*ctypes.ResultABCIQuery, error) { +) (*coretypes.ResultABCIQuery, error) { return c.ABCIQueryWithOptions(ctx, path, data, rpcclient.DefaultABCIQueryOptions) } @@ -230,8 +230,8 @@ func (c *baseRPCClient) ABCIQueryWithOptions( ctx context.Context, path string, data bytes.HexBytes, - opts rpcclient.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) { - result := new(ctypes.ResultABCIQuery) + opts rpcclient.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { + result := new(coretypes.ResultABCIQuery) _, err := c.caller.Call(ctx, "abci_query", map[string]interface{}{"path": path, "data": data, "height": opts.Height, "prove": opts.Prove}, result) @@ -245,8 +245,8 @@ func (c *baseRPCClient) ABCIQueryWithOptions( func (c *baseRPCClient) BroadcastTxCommit( ctx context.Context, tx types.Tx, -) (*ctypes.ResultBroadcastTxCommit, error) { - result := new(ctypes.ResultBroadcastTxCommit) +) (*coretypes.ResultBroadcastTxCommit, error) { + result := new(coretypes.ResultBroadcastTxCommit) _, err := c.caller.Call(ctx, "broadcast_tx_commit", map[string]interface{}{"tx": tx}, result) if err != nil { return nil, err @@ -257,14 +257,14 @@ func (c *baseRPCClient) BroadcastTxCommit( func (c *baseRPCClient) BroadcastTxAsync( ctx context.Context, tx types.Tx, -) (*ctypes.ResultBroadcastTx, error) { +) (*coretypes.ResultBroadcastTx, error) { return c.broadcastTX(ctx, "broadcast_tx_async", tx) } func (c *baseRPCClient) BroadcastTxSync( ctx context.Context, tx types.Tx, -) (*ctypes.ResultBroadcastTx, error) { +) (*coretypes.ResultBroadcastTx, error) { return c.broadcastTX(ctx, "broadcast_tx_sync", tx) } @@ -272,8 +272,8 @@ func (c *baseRPCClient) broadcastTX( ctx context.Context, route string, tx types.Tx, -) (*ctypes.ResultBroadcastTx, error) { - result := new(ctypes.ResultBroadcastTx) +) (*coretypes.ResultBroadcastTx, error) { + result := new(coretypes.ResultBroadcastTx) _, err := c.caller.Call(ctx, route, map[string]interface{}{"tx": tx}, result) if err != nil { return nil, err @@ -284,8 +284,8 @@ func (c *baseRPCClient) broadcastTX( func (c *baseRPCClient) UnconfirmedTxs( ctx context.Context, limit *int, -) (*ctypes.ResultUnconfirmedTxs, error) { - result := new(ctypes.ResultUnconfirmedTxs) +) (*coretypes.ResultUnconfirmedTxs, error) { + result := new(coretypes.ResultUnconfirmedTxs) params := make(map[string]interface{}) if limit != nil { params["limit"] = limit @@ -297,8 +297,8 @@ func (c *baseRPCClient) UnconfirmedTxs( return result, nil } -func (c *baseRPCClient) NumUnconfirmedTxs(ctx context.Context) (*ctypes.ResultUnconfirmedTxs, error) { - result := new(ctypes.ResultUnconfirmedTxs) +func (c *baseRPCClient) NumUnconfirmedTxs(ctx context.Context) (*coretypes.ResultUnconfirmedTxs, error) { + result := new(coretypes.ResultUnconfirmedTxs) _, err := c.caller.Call(ctx, "num_unconfirmed_txs", map[string]interface{}{}, result) if err != nil { return nil, err @@ -306,8 +306,8 @@ func (c *baseRPCClient) NumUnconfirmedTxs(ctx context.Context) (*ctypes.ResultUn return result, nil } -func (c *baseRPCClient) CheckTx(ctx context.Context, tx types.Tx) (*ctypes.ResultCheckTx, error) { - result := new(ctypes.ResultCheckTx) +func (c *baseRPCClient) CheckTx(ctx context.Context, tx types.Tx) (*coretypes.ResultCheckTx, error) { + result := new(coretypes.ResultCheckTx) _, err := c.caller.Call(ctx, "check_tx", map[string]interface{}{"tx": tx}, result) if err != nil { return nil, err @@ -315,8 +315,8 @@ func (c *baseRPCClient) CheckTx(ctx context.Context, tx types.Tx) (*ctypes.Resul return result, nil } -func (c *baseRPCClient) NetInfo(ctx context.Context) (*ctypes.ResultNetInfo, error) { - result := new(ctypes.ResultNetInfo) +func (c *baseRPCClient) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) { + result := new(coretypes.ResultNetInfo) _, err := c.caller.Call(ctx, "net_info", map[string]interface{}{}, result) if err != nil { return nil, err @@ -324,8 +324,8 @@ func (c *baseRPCClient) NetInfo(ctx context.Context) (*ctypes.ResultNetInfo, err return result, nil } -func (c *baseRPCClient) DumpConsensusState(ctx context.Context) (*ctypes.ResultDumpConsensusState, error) { - result := new(ctypes.ResultDumpConsensusState) +func (c *baseRPCClient) DumpConsensusState(ctx context.Context) (*coretypes.ResultDumpConsensusState, error) { + result := new(coretypes.ResultDumpConsensusState) _, err := c.caller.Call(ctx, "dump_consensus_state", map[string]interface{}{}, result) if err != nil { return nil, err @@ -333,8 +333,8 @@ func (c *baseRPCClient) DumpConsensusState(ctx context.Context) (*ctypes.ResultD return result, nil } -func (c *baseRPCClient) ConsensusState(ctx context.Context) (*ctypes.ResultConsensusState, error) { - result := new(ctypes.ResultConsensusState) +func (c *baseRPCClient) ConsensusState(ctx context.Context) (*coretypes.ResultConsensusState, error) { + result := new(coretypes.ResultConsensusState) _, err := c.caller.Call(ctx, "consensus_state", map[string]interface{}{}, result) if err != nil { return nil, err @@ -345,8 +345,8 @@ func (c *baseRPCClient) ConsensusState(ctx context.Context) (*ctypes.ResultConse func (c *baseRPCClient) ConsensusParams( ctx context.Context, height *int64, -) (*ctypes.ResultConsensusParams, error) { - result := new(ctypes.ResultConsensusParams) +) (*coretypes.ResultConsensusParams, error) { + result := new(coretypes.ResultConsensusParams) params := make(map[string]interface{}) if height != nil { params["height"] = height @@ -358,8 +358,8 @@ func (c *baseRPCClient) ConsensusParams( return result, nil } -func (c *baseRPCClient) Health(ctx context.Context) (*ctypes.ResultHealth, error) { - result := new(ctypes.ResultHealth) +func (c *baseRPCClient) Health(ctx context.Context) (*coretypes.ResultHealth, error) { + result := new(coretypes.ResultHealth) _, err := c.caller.Call(ctx, "health", map[string]interface{}{}, result) if err != nil { return nil, err @@ -371,8 +371,8 @@ func (c *baseRPCClient) BlockchainInfo( ctx context.Context, minHeight, maxHeight int64, -) (*ctypes.ResultBlockchainInfo, error) { - result := new(ctypes.ResultBlockchainInfo) +) (*coretypes.ResultBlockchainInfo, error) { + result := new(coretypes.ResultBlockchainInfo) _, err := c.caller.Call(ctx, "blockchain", map[string]interface{}{"minHeight": minHeight, "maxHeight": maxHeight}, result) @@ -382,8 +382,8 @@ func (c *baseRPCClient) BlockchainInfo( return result, nil } -func (c *baseRPCClient) Genesis(ctx context.Context) (*ctypes.ResultGenesis, error) { - result := new(ctypes.ResultGenesis) +func (c *baseRPCClient) Genesis(ctx context.Context) (*coretypes.ResultGenesis, error) { + result := new(coretypes.ResultGenesis) _, err := c.caller.Call(ctx, "genesis", map[string]interface{}{}, result) if err != nil { return nil, err @@ -391,8 +391,8 @@ func (c *baseRPCClient) Genesis(ctx context.Context) (*ctypes.ResultGenesis, err return result, nil } -func (c *baseRPCClient) GenesisChunked(ctx context.Context, id uint) (*ctypes.ResultGenesisChunk, error) { - result := new(ctypes.ResultGenesisChunk) +func (c *baseRPCClient) GenesisChunked(ctx context.Context, id uint) (*coretypes.ResultGenesisChunk, error) { + result := new(coretypes.ResultGenesisChunk) _, err := c.caller.Call(ctx, "genesis_chunked", map[string]interface{}{"chunk": id}, result) if err != nil { return nil, err @@ -400,8 +400,8 @@ func (c *baseRPCClient) GenesisChunked(ctx context.Context, id uint) (*ctypes.Re return result, nil } -func (c *baseRPCClient) Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error) { - result := new(ctypes.ResultBlock) +func (c *baseRPCClient) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { + result := new(coretypes.ResultBlock) params := make(map[string]interface{}) if height != nil { params["height"] = height @@ -413,8 +413,8 @@ func (c *baseRPCClient) Block(ctx context.Context, height *int64) (*ctypes.Resul return result, nil } -func (c *baseRPCClient) BlockByHash(ctx context.Context, hash bytes.HexBytes) (*ctypes.ResultBlock, error) { - result := new(ctypes.ResultBlock) +func (c *baseRPCClient) BlockByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultBlock, error) { + result := new(coretypes.ResultBlock) params := map[string]interface{}{ "hash": hash, } @@ -428,8 +428,8 @@ func (c *baseRPCClient) BlockByHash(ctx context.Context, hash bytes.HexBytes) (* func (c *baseRPCClient) BlockResults( ctx context.Context, height *int64, -) (*ctypes.ResultBlockResults, error) { - result := new(ctypes.ResultBlockResults) +) (*coretypes.ResultBlockResults, error) { + result := new(coretypes.ResultBlockResults) params := make(map[string]interface{}) if height != nil { params["height"] = height @@ -441,8 +441,8 @@ func (c *baseRPCClient) BlockResults( return result, nil } -func (c *baseRPCClient) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) { - result := new(ctypes.ResultCommit) +func (c *baseRPCClient) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { + result := new(coretypes.ResultCommit) params := make(map[string]interface{}) if height != nil { params["height"] = height @@ -454,8 +454,8 @@ func (c *baseRPCClient) Commit(ctx context.Context, height *int64) (*ctypes.Resu return result, nil } -func (c *baseRPCClient) Tx(ctx context.Context, hash bytes.HexBytes, prove bool) (*ctypes.ResultTx, error) { - result := new(ctypes.ResultTx) +func (c *baseRPCClient) Tx(ctx context.Context, hash bytes.HexBytes, prove bool) (*coretypes.ResultTx, error) { + result := new(coretypes.ResultTx) params := map[string]interface{}{ "hash": hash, "prove": prove, @@ -474,9 +474,9 @@ func (c *baseRPCClient) TxSearch( page, perPage *int, orderBy string, -) (*ctypes.ResultTxSearch, error) { +) (*coretypes.ResultTxSearch, error) { - result := new(ctypes.ResultTxSearch) + result := new(coretypes.ResultTxSearch) params := map[string]interface{}{ "query": query, "prove": prove, @@ -503,9 +503,9 @@ func (c *baseRPCClient) BlockSearch( query string, page, perPage *int, orderBy string, -) (*ctypes.ResultBlockSearch, error) { +) (*coretypes.ResultBlockSearch, error) { - result := new(ctypes.ResultBlockSearch) + result := new(coretypes.ResultBlockSearch) params := map[string]interface{}{ "query": query, "order_by": orderBy, @@ -531,8 +531,8 @@ func (c *baseRPCClient) Validators( height *int64, page, perPage *int, -) (*ctypes.ResultValidators, error) { - result := new(ctypes.ResultValidators) +) (*coretypes.ResultValidators, error) { + result := new(coretypes.ResultValidators) params := make(map[string]interface{}) if page != nil { params["page"] = page @@ -553,8 +553,8 @@ func (c *baseRPCClient) Validators( func (c *baseRPCClient) BroadcastEvidence( ctx context.Context, ev types.Evidence, -) (*ctypes.ResultBroadcastEvidence, error) { - result := new(ctypes.ResultBroadcastEvidence) +) (*coretypes.ResultBroadcastEvidence, error) { + result := new(coretypes.ResultBroadcastEvidence) _, err := c.caller.Call(ctx, "broadcast_evidence", map[string]interface{}{"evidence": ev}, result) if err != nil { return nil, err diff --git a/rpc/client/http/ws.go b/rpc/client/http/ws.go index 1735ca9c3..0f908e271 100644 --- a/rpc/client/http/ws.go +++ b/rpc/client/http/ws.go @@ -9,9 +9,9 @@ import ( tmsync "github.com/tendermint/tendermint/internal/libs/sync" tmjson "github.com/tendermint/tendermint/libs/json" - tmpubsub "github.com/tendermint/tendermint/libs/pubsub" + "github.com/tendermint/tendermint/libs/pubsub" rpcclient "github.com/tendermint/tendermint/rpc/client" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" jsonrpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client" ) @@ -53,7 +53,7 @@ type wsEvents struct { } type wsSubscription struct { - res chan ctypes.ResultEvent + res chan coretypes.ResultEvent id string query string } @@ -119,7 +119,7 @@ func (w *wsEvents) Stop() error { return w.ws.Stop() } // // It returns an error if wsEvents is not running. func (w *wsEvents) Subscribe(ctx context.Context, subscriber, query string, - outCapacity ...int) (out <-chan ctypes.ResultEvent, err error) { + outCapacity ...int) (out <-chan coretypes.ResultEvent, err error) { if !w.IsRunning() { return nil, rpcclient.ErrClientNotRunning @@ -134,7 +134,7 @@ func (w *wsEvents) Subscribe(ctx context.Context, subscriber, query string, outCap = outCapacity[0] } - outc := make(chan ctypes.ResultEvent, outCap) + outc := make(chan coretypes.ResultEvent, outCap) w.mtx.Lock() defer w.mtx.Unlock() // subscriber param is ignored because Tendermint will override it with @@ -213,7 +213,7 @@ func (w *wsEvents) redoSubscriptionsAfter(d time.Duration) { } func isErrAlreadySubscribed(err error) bool { - return strings.Contains(err.Error(), tmpubsub.ErrAlreadySubscribed.Error()) + return strings.Contains(err.Error(), pubsub.ErrAlreadySubscribed.Error()) } func (w *wsEvents) eventListener() { @@ -238,7 +238,7 @@ func (w *wsEvents) eventListener() { continue } - result := new(ctypes.ResultEvent) + result := new(coretypes.ResultEvent) err := tmjson.Unmarshal(resp.Result, result) if err != nil { w.Logger.Error("failed to unmarshal response", "err", err) diff --git a/rpc/client/interface.go b/rpc/client/interface.go index ae54928df..7b6a9bd20 100644 --- a/rpc/client/interface.go +++ b/rpc/client/interface.go @@ -24,7 +24,7 @@ import ( "context" "github.com/tendermint/tendermint/libs/bytes" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" "github.com/tendermint/tendermint/types" ) @@ -61,26 +61,26 @@ type Client interface { // is easier to mock. type ABCIClient interface { // Reading from abci app - ABCIInfo(context.Context) (*ctypes.ResultABCIInfo, error) - ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error) + ABCIInfo(context.Context) (*coretypes.ResultABCIInfo, error) + ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) ABCIQueryWithOptions(ctx context.Context, path string, data bytes.HexBytes, - opts ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) + opts ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) // Writing to abci app - BroadcastTxCommit(context.Context, types.Tx) (*ctypes.ResultBroadcastTxCommit, error) - BroadcastTxAsync(context.Context, types.Tx) (*ctypes.ResultBroadcastTx, error) - BroadcastTxSync(context.Context, types.Tx) (*ctypes.ResultBroadcastTx, error) + BroadcastTxCommit(context.Context, types.Tx) (*coretypes.ResultBroadcastTxCommit, error) + BroadcastTxAsync(context.Context, types.Tx) (*coretypes.ResultBroadcastTx, error) + BroadcastTxSync(context.Context, types.Tx) (*coretypes.ResultBroadcastTx, error) } // SignClient groups together the functionality needed to get valid signatures // and prove anything about the chain. type SignClient interface { - Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error) - BlockByHash(ctx context.Context, hash bytes.HexBytes) (*ctypes.ResultBlock, error) - BlockResults(ctx context.Context, height *int64) (*ctypes.ResultBlockResults, error) - Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) - Validators(ctx context.Context, height *int64, page, perPage *int) (*ctypes.ResultValidators, error) - Tx(ctx context.Context, hash bytes.HexBytes, prove bool) (*ctypes.ResultTx, error) + Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) + BlockByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultBlock, error) + BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) + Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) + Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) + Tx(ctx context.Context, hash bytes.HexBytes, prove bool) (*coretypes.ResultTx, error) // TxSearch defines a method to search for a paginated set of transactions by // DeliverTx event search criteria. @@ -90,7 +90,7 @@ type SignClient interface { prove bool, page, perPage *int, orderBy string, - ) (*ctypes.ResultTxSearch, error) + ) (*coretypes.ResultTxSearch, error) // BlockSearch defines a method to search for a paginated set of blocks by // BeginBlock and EndBlock event search criteria. @@ -99,29 +99,29 @@ type SignClient interface { query string, page, perPage *int, orderBy string, - ) (*ctypes.ResultBlockSearch, error) + ) (*coretypes.ResultBlockSearch, error) } // HistoryClient provides access to data from genesis to now in large chunks. type HistoryClient interface { - Genesis(context.Context) (*ctypes.ResultGenesis, error) - GenesisChunked(context.Context, uint) (*ctypes.ResultGenesisChunk, error) - BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) + Genesis(context.Context) (*coretypes.ResultGenesis, error) + GenesisChunked(context.Context, uint) (*coretypes.ResultGenesisChunk, error) + BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) } // StatusClient provides access to general chain info. type StatusClient interface { - Status(context.Context) (*ctypes.ResultStatus, error) + Status(context.Context) (*coretypes.ResultStatus, error) } // NetworkClient is general info about the network state. May not be needed // usually. type NetworkClient interface { - NetInfo(context.Context) (*ctypes.ResultNetInfo, error) - DumpConsensusState(context.Context) (*ctypes.ResultDumpConsensusState, error) - ConsensusState(context.Context) (*ctypes.ResultConsensusState, error) - ConsensusParams(ctx context.Context, height *int64) (*ctypes.ResultConsensusParams, error) - Health(context.Context) (*ctypes.ResultHealth, error) + NetInfo(context.Context) (*coretypes.ResultNetInfo, error) + DumpConsensusState(context.Context) (*coretypes.ResultDumpConsensusState, error) + ConsensusState(context.Context) (*coretypes.ResultConsensusState, error) + ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) + Health(context.Context) (*coretypes.ResultHealth, error) } // EventsClient is reactive, you can subscribe to any message, given the proper @@ -134,7 +134,7 @@ type EventsClient interface { // // ctx cannot be used to unsubscribe. To unsubscribe, use either Unsubscribe // or UnsubscribeAll. - Subscribe(ctx context.Context, subscriber, query string, outCapacity ...int) (out <-chan ctypes.ResultEvent, err error) + Subscribe(ctx context.Context, subscriber, query string, outCapacity ...int) (out <-chan coretypes.ResultEvent, err error) //nolint:lll // Unsubscribe unsubscribes given subscriber from query. Unsubscribe(ctx context.Context, subscriber, query string) error // UnsubscribeAll unsubscribes given subscriber from all the queries. @@ -143,15 +143,15 @@ type EventsClient interface { // MempoolClient shows us data about current mempool state. type MempoolClient interface { - UnconfirmedTxs(ctx context.Context, limit *int) (*ctypes.ResultUnconfirmedTxs, error) - NumUnconfirmedTxs(context.Context) (*ctypes.ResultUnconfirmedTxs, error) - CheckTx(context.Context, types.Tx) (*ctypes.ResultCheckTx, error) + UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) + NumUnconfirmedTxs(context.Context) (*coretypes.ResultUnconfirmedTxs, error) + CheckTx(context.Context, types.Tx) (*coretypes.ResultCheckTx, error) } // EvidenceClient is used for submitting an evidence of the malicious // behavior. type EvidenceClient interface { - BroadcastEvidence(context.Context, types.Evidence) (*ctypes.ResultBroadcastEvidence, error) + BroadcastEvidence(context.Context, types.Evidence) (*coretypes.ResultBroadcastEvidence, error) } // RemoteClient is a Client, which can also return the remote network address. diff --git a/rpc/client/local/local.go b/rpc/client/local/local.go index 2080e0d44..85302691d 100644 --- a/rpc/client/local/local.go +++ b/rpc/client/local/local.go @@ -9,10 +9,10 @@ import ( rpccore "github.com/tendermint/tendermint/internal/rpc/core" "github.com/tendermint/tendermint/libs/bytes" "github.com/tendermint/tendermint/libs/log" - tmpubsub "github.com/tendermint/tendermint/libs/pubsub" - tmquery "github.com/tendermint/tendermint/libs/pubsub/query" + "github.com/tendermint/tendermint/libs/pubsub" + "github.com/tendermint/tendermint/libs/pubsub/query" rpcclient "github.com/tendermint/tendermint/rpc/client" - 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" ) @@ -72,15 +72,15 @@ func (c *Local) SetLogger(l log.Logger) { c.Logger = l } -func (c *Local) Status(ctx context.Context) (*ctypes.ResultStatus, error) { +func (c *Local) Status(ctx context.Context) (*coretypes.ResultStatus, error) { return c.env.Status(c.ctx) } -func (c *Local) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) { +func (c *Local) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { return c.env.ABCIInfo(c.ctx) } -func (c *Local) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error) { +func (c *Local) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { return c.ABCIQueryWithOptions(ctx, path, data, rpcclient.DefaultABCIQueryOptions) } @@ -88,55 +88,55 @@ func (c *Local) ABCIQueryWithOptions( ctx context.Context, path string, data bytes.HexBytes, - opts rpcclient.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) { + opts rpcclient.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { return c.env.ABCIQuery(c.ctx, path, data, opts.Height, opts.Prove) } -func (c *Local) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { +func (c *Local) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { return c.env.BroadcastTxCommit(c.ctx, tx) } -func (c *Local) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (c *Local) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.env.BroadcastTxAsync(c.ctx, tx) } -func (c *Local) BroadcastTxSync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (c *Local) BroadcastTxSync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.env.BroadcastTxSync(c.ctx, tx) } -func (c *Local) UnconfirmedTxs(ctx context.Context, limit *int) (*ctypes.ResultUnconfirmedTxs, error) { +func (c *Local) UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) { return c.env.UnconfirmedTxs(c.ctx, limit) } -func (c *Local) NumUnconfirmedTxs(ctx context.Context) (*ctypes.ResultUnconfirmedTxs, error) { +func (c *Local) NumUnconfirmedTxs(ctx context.Context) (*coretypes.ResultUnconfirmedTxs, error) { return c.env.NumUnconfirmedTxs(c.ctx) } -func (c *Local) CheckTx(ctx context.Context, tx types.Tx) (*ctypes.ResultCheckTx, error) { +func (c *Local) CheckTx(ctx context.Context, tx types.Tx) (*coretypes.ResultCheckTx, error) { return c.env.CheckTx(c.ctx, tx) } -func (c *Local) NetInfo(ctx context.Context) (*ctypes.ResultNetInfo, error) { +func (c *Local) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) { return c.env.NetInfo(c.ctx) } -func (c *Local) DumpConsensusState(ctx context.Context) (*ctypes.ResultDumpConsensusState, error) { +func (c *Local) DumpConsensusState(ctx context.Context) (*coretypes.ResultDumpConsensusState, error) { return c.env.DumpConsensusState(c.ctx) } -func (c *Local) ConsensusState(ctx context.Context) (*ctypes.ResultConsensusState, error) { +func (c *Local) ConsensusState(ctx context.Context) (*coretypes.ResultConsensusState, error) { return c.env.GetConsensusState(c.ctx) } -func (c *Local) ConsensusParams(ctx context.Context, height *int64) (*ctypes.ResultConsensusParams, error) { +func (c *Local) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) { return c.env.ConsensusParams(c.ctx, height) } -func (c *Local) Health(ctx context.Context) (*ctypes.ResultHealth, error) { +func (c *Local) Health(ctx context.Context) (*coretypes.ResultHealth, error) { return c.env.Health(c.ctx) } -func (c *Local) DialSeeds(ctx context.Context, seeds []string) (*ctypes.ResultDialSeeds, error) { +func (c *Local) DialSeeds(ctx context.Context, seeds []string) (*coretypes.ResultDialSeeds, error) { return c.env.UnsafeDialSeeds(c.ctx, seeds) } @@ -146,76 +146,76 @@ func (c *Local) DialPeers( persistent, unconditional, private bool, -) (*ctypes.ResultDialPeers, error) { +) (*coretypes.ResultDialPeers, error) { return c.env.UnsafeDialPeers(c.ctx, peers, persistent, unconditional, private) } -func (c *Local) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) { +func (c *Local) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { //nolint:lll return c.env.BlockchainInfo(c.ctx, minHeight, maxHeight) } -func (c *Local) Genesis(ctx context.Context) (*ctypes.ResultGenesis, error) { +func (c *Local) Genesis(ctx context.Context) (*coretypes.ResultGenesis, error) { return c.env.Genesis(c.ctx) } -func (c *Local) GenesisChunked(ctx context.Context, id uint) (*ctypes.ResultGenesisChunk, error) { +func (c *Local) GenesisChunked(ctx context.Context, id uint) (*coretypes.ResultGenesisChunk, error) { return c.env.GenesisChunked(c.ctx, id) } -func (c *Local) Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error) { +func (c *Local) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { return c.env.Block(c.ctx, height) } -func (c *Local) BlockByHash(ctx context.Context, hash bytes.HexBytes) (*ctypes.ResultBlock, error) { +func (c *Local) BlockByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultBlock, error) { return c.env.BlockByHash(c.ctx, hash) } -func (c *Local) BlockResults(ctx context.Context, height *int64) (*ctypes.ResultBlockResults, error) { +func (c *Local) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) { return c.env.BlockResults(c.ctx, height) } -func (c *Local) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) { +func (c *Local) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { return c.env.Commit(c.ctx, height) } -func (c *Local) Validators(ctx context.Context, height *int64, page, perPage *int) (*ctypes.ResultValidators, error) { +func (c *Local) Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) { //nolint:lll return c.env.Validators(c.ctx, height, page, perPage) } -func (c *Local) Tx(ctx context.Context, hash bytes.HexBytes, prove bool) (*ctypes.ResultTx, error) { +func (c *Local) Tx(ctx context.Context, hash bytes.HexBytes, prove bool) (*coretypes.ResultTx, error) { return c.env.Tx(c.ctx, hash, prove) } func (c *Local) TxSearch( _ context.Context, - query string, + queryString string, prove bool, page, perPage *int, orderBy string, -) (*ctypes.ResultTxSearch, error) { - return c.env.TxSearch(c.ctx, query, prove, page, perPage, orderBy) +) (*coretypes.ResultTxSearch, error) { + return c.env.TxSearch(c.ctx, queryString, prove, page, perPage, orderBy) } func (c *Local) BlockSearch( _ context.Context, - query string, + queryString string, page, perPage *int, orderBy string, -) (*ctypes.ResultBlockSearch, error) { - return c.env.BlockSearch(c.ctx, query, page, perPage, orderBy) +) (*coretypes.ResultBlockSearch, error) { + return c.env.BlockSearch(c.ctx, queryString, page, perPage, orderBy) } -func (c *Local) BroadcastEvidence(ctx context.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) { +func (c *Local) BroadcastEvidence(ctx context.Context, ev types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { return c.env.BroadcastEvidence(c.ctx, ev) } func (c *Local) Subscribe( ctx context.Context, subscriber, - query string, - outCapacity ...int) (out <-chan ctypes.ResultEvent, err error) { - q, err := tmquery.New(query) + queryString string, + outCapacity ...int) (out <-chan coretypes.ResultEvent, err error) { + q, err := query.New(queryString) if err != nil { return nil, fmt.Errorf("failed to parse query: %w", err) } @@ -235,7 +235,7 @@ func (c *Local) Subscribe( return nil, fmt.Errorf("failed to subscribe: %w", err) } - outc := make(chan ctypes.ResultEvent, outCap) + outc := make(chan coretypes.ResultEvent, outCap) go c.eventsRoutine(sub, subscriber, q, outc) return outc, nil @@ -244,12 +244,12 @@ func (c *Local) Subscribe( func (c *Local) eventsRoutine( sub types.Subscription, subscriber string, - q tmpubsub.Query, - outc chan<- ctypes.ResultEvent) { + q pubsub.Query, + outc chan<- coretypes.ResultEvent) { for { select { case msg := <-sub.Out(): - result := ctypes.ResultEvent{ + result := coretypes.ResultEvent{ SubscriptionID: msg.SubscriptionID(), Query: q.String(), Data: msg.Data(), @@ -266,7 +266,7 @@ func (c *Local) eventsRoutine( } } case <-sub.Canceled(): - if sub.Err() == tmpubsub.ErrUnsubscribed { + if sub.Err() == pubsub.ErrUnsubscribed { return } @@ -282,7 +282,7 @@ func (c *Local) eventsRoutine( } // Try to resubscribe with exponential backoff. -func (c *Local) resubscribe(subscriber string, q tmpubsub.Query) types.Subscription { +func (c *Local) resubscribe(subscriber string, q pubsub.Query) types.Subscription { attempts := 0 for { if !c.IsRunning() { @@ -299,17 +299,17 @@ func (c *Local) resubscribe(subscriber string, q tmpubsub.Query) types.Subscript } } -func (c *Local) Unsubscribe(ctx context.Context, subscriber, query string) error { - args := tmpubsub.UnsubscribeArgs{Subscriber: subscriber} +func (c *Local) Unsubscribe(ctx context.Context, subscriber, queryString string) error { + args := pubsub.UnsubscribeArgs{Subscriber: subscriber} var err error - args.Query, err = tmquery.New(query) + args.Query, err = query.New(queryString) if err != nil { // if this isn't a valid query it might be an ID, so // we'll try that. It'll turn into an error when we // try to unsubscribe. Eventually, perhaps, we'll want // to change the interface to only allow // unsubscription by ID, but that's a larger change. - args.ID = query + args.ID = queryString } return c.EventBus.Unsubscribe(ctx, args) } diff --git a/rpc/client/mock/abci.go b/rpc/client/mock/abci.go index 0186ee9cc..700b08f5e 100644 --- a/rpc/client/mock/abci.go +++ b/rpc/client/mock/abci.go @@ -7,7 +7,7 @@ import ( "github.com/tendermint/tendermint/internal/proxy" "github.com/tendermint/tendermint/libs/bytes" "github.com/tendermint/tendermint/rpc/client" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" "github.com/tendermint/tendermint/types" ) @@ -24,11 +24,11 @@ var ( _ client.ABCIClient = (*ABCIRecorder)(nil) ) -func (a ABCIApp) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) { - return &ctypes.ResultABCIInfo{Response: a.App.Info(proxy.RequestInfo)}, nil +func (a ABCIApp) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { + return &coretypes.ResultABCIInfo{Response: a.App.Info(proxy.RequestInfo)}, nil } -func (a ABCIApp) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error) { +func (a ABCIApp) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { return a.ABCIQueryWithOptions(ctx, path, data, client.DefaultABCIQueryOptions) } @@ -36,21 +36,21 @@ func (a ABCIApp) ABCIQueryWithOptions( ctx context.Context, path string, data bytes.HexBytes, - opts client.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) { + opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { q := a.App.Query(abci.RequestQuery{ Data: data, Path: path, Height: opts.Height, Prove: opts.Prove, }) - return &ctypes.ResultABCIQuery{Response: q}, nil + return &coretypes.ResultABCIQuery{Response: q}, nil } // NOTE: Caller should call a.App.Commit() separately, // this function does not actually wait for a commit. // TODO: Make it wait for a commit and set res.Height appropriately. -func (a ABCIApp) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { - res := ctypes.ResultBroadcastTxCommit{} +func (a ABCIApp) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { + res := coretypes.ResultBroadcastTxCommit{} res.CheckTx = a.App.CheckTx(abci.RequestCheckTx{Tx: tx}) if res.CheckTx.IsErr() { return &res, nil @@ -60,13 +60,13 @@ func (a ABCIApp) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.Re return &res, nil } -func (a ABCIApp) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (a ABCIApp) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { c := a.App.CheckTx(abci.RequestCheckTx{Tx: tx}) // and this gets written in a background thread... if !c.IsErr() { go func() { a.App.DeliverTx(abci.RequestDeliverTx{Tx: tx}) }() } - return &ctypes.ResultBroadcastTx{ + return &coretypes.ResultBroadcastTx{ Code: c.Code, Data: c.Data, Log: c.Log, @@ -75,13 +75,13 @@ func (a ABCIApp) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctypes.Res }, nil } -func (a ABCIApp) BroadcastTxSync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (a ABCIApp) BroadcastTxSync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { c := a.App.CheckTx(abci.RequestCheckTx{Tx: tx}) // and this gets written in a background thread... if !c.IsErr() { go func() { a.App.DeliverTx(abci.RequestDeliverTx{Tx: tx}) }() } - return &ctypes.ResultBroadcastTx{ + return &coretypes.ResultBroadcastTx{ Code: c.Code, Data: c.Data, Log: c.Log, @@ -100,15 +100,15 @@ type ABCIMock struct { Broadcast Call } -func (m ABCIMock) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) { +func (m ABCIMock) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { res, err := m.Info.GetResponse(nil) if err != nil { return nil, err } - return &ctypes.ResultABCIInfo{Response: res.(abci.ResponseInfo)}, nil + return &coretypes.ResultABCIInfo{Response: res.(abci.ResponseInfo)}, nil } -func (m ABCIMock) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error) { +func (m ABCIMock) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { return m.ABCIQueryWithOptions(ctx, path, data, client.DefaultABCIQueryOptions) } @@ -116,37 +116,37 @@ func (m ABCIMock) ABCIQueryWithOptions( ctx context.Context, path string, data bytes.HexBytes, - opts client.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) { + opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { res, err := m.Query.GetResponse(QueryArgs{path, data, opts.Height, opts.Prove}) if err != nil { return nil, err } resQuery := res.(abci.ResponseQuery) - return &ctypes.ResultABCIQuery{Response: resQuery}, nil + return &coretypes.ResultABCIQuery{Response: resQuery}, nil } -func (m ABCIMock) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { +func (m ABCIMock) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { res, err := m.BroadcastCommit.GetResponse(tx) if err != nil { return nil, err } - return res.(*ctypes.ResultBroadcastTxCommit), nil + return res.(*coretypes.ResultBroadcastTxCommit), nil } -func (m ABCIMock) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (m ABCIMock) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { res, err := m.Broadcast.GetResponse(tx) if err != nil { return nil, err } - return res.(*ctypes.ResultBroadcastTx), nil + return res.(*coretypes.ResultBroadcastTx), nil } -func (m ABCIMock) BroadcastTxSync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (m ABCIMock) BroadcastTxSync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { res, err := m.Broadcast.GetResponse(tx) if err != nil { return nil, err } - return res.(*ctypes.ResultBroadcastTx), nil + return res.(*coretypes.ResultBroadcastTx), nil } // ABCIRecorder can wrap another type (ABCIApp, ABCIMock, or Client) @@ -174,7 +174,7 @@ func (r *ABCIRecorder) addCall(call Call) { r.Calls = append(r.Calls, call) } -func (r *ABCIRecorder) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) { +func (r *ABCIRecorder) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { res, err := r.Client.ABCIInfo(ctx) r.addCall(Call{ Name: "abci_info", @@ -188,7 +188,7 @@ func (r *ABCIRecorder) ABCIQuery( ctx context.Context, path string, data bytes.HexBytes, -) (*ctypes.ResultABCIQuery, error) { +) (*coretypes.ResultABCIQuery, error) { return r.ABCIQueryWithOptions(ctx, path, data, client.DefaultABCIQueryOptions) } @@ -196,7 +196,7 @@ func (r *ABCIRecorder) ABCIQueryWithOptions( ctx context.Context, path string, data bytes.HexBytes, - opts client.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) { + opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { res, err := r.Client.ABCIQueryWithOptions(ctx, path, data, opts) r.addCall(Call{ Name: "abci_query", @@ -207,7 +207,7 @@ func (r *ABCIRecorder) ABCIQueryWithOptions( return res, err } -func (r *ABCIRecorder) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { +func (r *ABCIRecorder) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { res, err := r.Client.BroadcastTxCommit(ctx, tx) r.addCall(Call{ Name: "broadcast_tx_commit", @@ -218,7 +218,7 @@ func (r *ABCIRecorder) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*cty return res, err } -func (r *ABCIRecorder) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (r *ABCIRecorder) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { res, err := r.Client.BroadcastTxAsync(ctx, tx) r.addCall(Call{ Name: "broadcast_tx_async", @@ -229,7 +229,7 @@ func (r *ABCIRecorder) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctyp return res, err } -func (r *ABCIRecorder) BroadcastTxSync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (r *ABCIRecorder) BroadcastTxSync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { res, err := r.Client.BroadcastTxSync(ctx, tx) r.addCall(Call{ Name: "broadcast_tx_sync", diff --git a/rpc/client/mock/abci_test.go b/rpc/client/mock/abci_test.go index 206b8fac2..25fbbc05d 100644 --- a/rpc/client/mock/abci_test.go +++ b/rpc/client/mock/abci_test.go @@ -14,7 +14,7 @@ import ( "github.com/tendermint/tendermint/libs/bytes" "github.com/tendermint/tendermint/rpc/client" "github.com/tendermint/tendermint/rpc/client/mock" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" "github.com/tendermint/tendermint/types" ) @@ -36,7 +36,7 @@ func TestABCIMock(t *testing.T) { // Broadcast commit depends on call BroadcastCommit: mock.Call{ Args: goodTx, - Response: &ctypes.ResultBroadcastTxCommit{ + Response: &coretypes.ResultBroadcastTxCommit{ CheckTx: abci.ResponseCheckTx{Data: bytes.HexBytes("stand")}, DeliverTx: abci.ResponseDeliverTx{Data: bytes.HexBytes("deliver")}, }, @@ -112,7 +112,7 @@ func TestABCIRecorder(t *testing.T) { assert.Nil(info.Error) assert.Nil(info.Args) require.NotNil(info.Response) - ir, ok := info.Response.(*ctypes.ResultABCIInfo) + ir, ok := info.Response.(*coretypes.ResultABCIInfo) require.True(ok) assert.Equal("data", ir.Response.Data) assert.Equal("v0.9.9", ir.Response.Version) diff --git a/rpc/client/mock/client.go b/rpc/client/mock/client.go index b0f27ae88..4b858d067 100644 --- a/rpc/client/mock/client.go +++ b/rpc/client/mock/client.go @@ -21,7 +21,7 @@ import ( "github.com/tendermint/tendermint/internal/rpc/core" "github.com/tendermint/tendermint/libs/bytes" "github.com/tendermint/tendermint/rpc/client" - 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" ) @@ -75,15 +75,15 @@ func (c Call) GetResponse(args interface{}) (interface{}, error) { return nil, c.Error } -func (c Client) Status(ctx context.Context) (*ctypes.ResultStatus, error) { +func (c Client) Status(ctx context.Context) (*coretypes.ResultStatus, error) { return c.env.Status(&rpctypes.Context{}) } -func (c Client) ABCIInfo(ctx context.Context) (*ctypes.ResultABCIInfo, error) { +func (c Client) ABCIInfo(ctx context.Context) (*coretypes.ResultABCIInfo, error) { return c.env.ABCIInfo(&rpctypes.Context{}) } -func (c Client) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*ctypes.ResultABCIQuery, error) { +func (c Client) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) { return c.ABCIQueryWithOptions(ctx, path, data, client.DefaultABCIQueryOptions) } @@ -91,47 +91,47 @@ func (c Client) ABCIQueryWithOptions( ctx context.Context, path string, data bytes.HexBytes, - opts client.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) { + opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) { return c.env.ABCIQuery(&rpctypes.Context{}, path, data, opts.Height, opts.Prove) } -func (c Client) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) { +func (c Client) BroadcastTxCommit(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTxCommit, error) { return c.env.BroadcastTxCommit(&rpctypes.Context{}, tx) } -func (c Client) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (c Client) BroadcastTxAsync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.env.BroadcastTxAsync(&rpctypes.Context{}, tx) } -func (c Client) BroadcastTxSync(ctx context.Context, tx types.Tx) (*ctypes.ResultBroadcastTx, error) { +func (c Client) BroadcastTxSync(ctx context.Context, tx types.Tx) (*coretypes.ResultBroadcastTx, error) { return c.env.BroadcastTxSync(&rpctypes.Context{}, tx) } -func (c Client) CheckTx(ctx context.Context, tx types.Tx) (*ctypes.ResultCheckTx, error) { +func (c Client) CheckTx(ctx context.Context, tx types.Tx) (*coretypes.ResultCheckTx, error) { return c.env.CheckTx(&rpctypes.Context{}, tx) } -func (c Client) NetInfo(ctx context.Context) (*ctypes.ResultNetInfo, error) { +func (c Client) NetInfo(ctx context.Context) (*coretypes.ResultNetInfo, error) { return c.env.NetInfo(&rpctypes.Context{}) } -func (c Client) ConsensusState(ctx context.Context) (*ctypes.ResultConsensusState, error) { +func (c Client) ConsensusState(ctx context.Context) (*coretypes.ResultConsensusState, error) { return c.env.GetConsensusState(&rpctypes.Context{}) } -func (c Client) DumpConsensusState(ctx context.Context) (*ctypes.ResultDumpConsensusState, error) { +func (c Client) DumpConsensusState(ctx context.Context) (*coretypes.ResultDumpConsensusState, error) { return c.env.DumpConsensusState(&rpctypes.Context{}) } -func (c Client) ConsensusParams(ctx context.Context, height *int64) (*ctypes.ResultConsensusParams, error) { +func (c Client) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) { return c.env.ConsensusParams(&rpctypes.Context{}, height) } -func (c Client) Health(ctx context.Context) (*ctypes.ResultHealth, error) { +func (c Client) Health(ctx context.Context) (*coretypes.ResultHealth, error) { return c.env.Health(&rpctypes.Context{}) } -func (c Client) DialSeeds(ctx context.Context, seeds []string) (*ctypes.ResultDialSeeds, error) { +func (c Client) DialSeeds(ctx context.Context, seeds []string) (*coretypes.ResultDialSeeds, error) { return c.env.UnsafeDialSeeds(&rpctypes.Context{}, seeds) } @@ -141,34 +141,34 @@ func (c Client) DialPeers( persistent, unconditional, private bool, -) (*ctypes.ResultDialPeers, error) { +) (*coretypes.ResultDialPeers, error) { return c.env.UnsafeDialPeers(&rpctypes.Context{}, peers, persistent, unconditional, private) } -func (c Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*ctypes.ResultBlockchainInfo, error) { +func (c Client) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) { //nolint:lll return c.env.BlockchainInfo(&rpctypes.Context{}, minHeight, maxHeight) } -func (c Client) Genesis(ctx context.Context) (*ctypes.ResultGenesis, error) { +func (c Client) Genesis(ctx context.Context) (*coretypes.ResultGenesis, error) { return c.env.Genesis(&rpctypes.Context{}) } -func (c Client) Block(ctx context.Context, height *int64) (*ctypes.ResultBlock, error) { +func (c Client) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) { return c.env.Block(&rpctypes.Context{}, height) } -func (c Client) BlockByHash(ctx context.Context, hash bytes.HexBytes) (*ctypes.ResultBlock, error) { +func (c Client) BlockByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultBlock, error) { return c.env.BlockByHash(&rpctypes.Context{}, hash) } -func (c Client) Commit(ctx context.Context, height *int64) (*ctypes.ResultCommit, error) { +func (c Client) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) { return c.env.Commit(&rpctypes.Context{}, height) } -func (c Client) Validators(ctx context.Context, height *int64, page, perPage *int) (*ctypes.ResultValidators, error) { +func (c Client) Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) { //nolint:lll return c.env.Validators(&rpctypes.Context{}, height, page, perPage) } -func (c Client) BroadcastEvidence(ctx context.Context, ev types.Evidence) (*ctypes.ResultBroadcastEvidence, error) { +func (c Client) BroadcastEvidence(ctx context.Context, ev types.Evidence) (*coretypes.ResultBroadcastEvidence, error) { return c.env.BroadcastEvidence(&rpctypes.Context{}, ev) } diff --git a/rpc/client/mock/status.go b/rpc/client/mock/status.go index 10da67008..22548e891 100644 --- a/rpc/client/mock/status.go +++ b/rpc/client/mock/status.go @@ -4,7 +4,7 @@ import ( "context" "github.com/tendermint/tendermint/rpc/client" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" ) // StatusMock returns the result specified by the Call @@ -17,12 +17,12 @@ var ( _ client.StatusClient = (*StatusRecorder)(nil) ) -func (m *StatusMock) Status(ctx context.Context) (*ctypes.ResultStatus, error) { +func (m *StatusMock) Status(ctx context.Context) (*coretypes.ResultStatus, error) { res, err := m.GetResponse(nil) if err != nil { return nil, err } - return res.(*ctypes.ResultStatus), nil + return res.(*coretypes.ResultStatus), nil } // StatusRecorder can wrap another type (StatusMock, full client) @@ -43,7 +43,7 @@ func (r *StatusRecorder) addCall(call Call) { r.Calls = append(r.Calls, call) } -func (r *StatusRecorder) Status(ctx context.Context) (*ctypes.ResultStatus, error) { +func (r *StatusRecorder) Status(ctx context.Context) (*coretypes.ResultStatus, error) { res, err := r.Client.Status(ctx) r.addCall(Call{ Name: "status", diff --git a/rpc/client/mock/status_test.go b/rpc/client/mock/status_test.go index 37dce6095..98655280e 100644 --- a/rpc/client/mock/status_test.go +++ b/rpc/client/mock/status_test.go @@ -10,7 +10,7 @@ import ( "github.com/tendermint/tendermint/libs/bytes" "github.com/tendermint/tendermint/rpc/client/mock" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" ) func TestStatus(t *testing.T) { @@ -18,8 +18,8 @@ func TestStatus(t *testing.T) { m := &mock.StatusMock{ Call: mock.Call{ - Response: &ctypes.ResultStatus{ - SyncInfo: ctypes.SyncInfo{ + Response: &coretypes.ResultStatus{ + SyncInfo: coretypes.SyncInfo{ LatestBlockHash: bytes.HexBytes("block"), LatestAppHash: bytes.HexBytes("app"), LatestBlockHeight: 10, @@ -56,7 +56,7 @@ func TestStatus(t *testing.T) { assert.Nil(rs.Args) assert.Nil(rs.Error) require.NotNil(rs.Response) - st, ok := rs.Response.(*ctypes.ResultStatus) + st, ok := rs.Response.(*coretypes.ResultStatus) require.True(ok) assert.EqualValues("block", st.SyncInfo.LatestBlockHash) assert.EqualValues(10, st.SyncInfo.LatestBlockHeight) diff --git a/rpc/client/rpc_test.go b/rpc/client/rpc_test.go index 5ad9e4244..8a6845831 100644 --- a/rpc/client/rpc_test.go +++ b/rpc/client/rpc_test.go @@ -16,7 +16,7 @@ import ( abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/config" - mempl "github.com/tendermint/tendermint/internal/mempool" + "github.com/tendermint/tendermint/internal/mempool" tmjson "github.com/tendermint/tendermint/libs/json" "github.com/tendermint/tendermint/libs/log" tmmath "github.com/tendermint/tendermint/libs/math" @@ -24,7 +24,7 @@ import ( "github.com/tendermint/tendermint/rpc/client" rpchttp "github.com/tendermint/tendermint/rpc/client/http" rpclocal "github.com/tendermint/tendermint/rpc/client/local" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" + "github.com/tendermint/tendermint/rpc/coretypes" rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client" "github.com/tendermint/tendermint/types" ) @@ -425,8 +425,8 @@ func TestBroadcastTxSync(t *testing.T) { defer cancel() // TODO (melekes): use mempool which is set on RPC rather than getting it from node - mempool := getMempool(t, n) - initMempoolSize := mempool.Size() + pool := getMempool(t, n) + initMempoolSize := pool.Size() for i, c := range GetClients(t, n, conf) { _, _, tx := MakeTxKV() @@ -434,18 +434,18 @@ func TestBroadcastTxSync(t *testing.T) { require.Nil(t, err, "%d: %+v", i, err) require.Equal(t, bres.Code, abci.CodeTypeOK) // FIXME - require.Equal(t, initMempoolSize+1, mempool.Size()) + require.Equal(t, initMempoolSize+1, pool.Size()) - txs := mempool.ReapMaxTxs(len(tx)) + txs := pool.ReapMaxTxs(len(tx)) require.EqualValues(t, tx, txs[0]) - mempool.Flush() + pool.Flush() } } -func getMempool(t *testing.T, srv service.Service) mempl.Mempool { +func getMempool(t *testing.T, srv service.Service) mempool.Mempool { t.Helper() n, ok := srv.(interface { - Mempool() mempl.Mempool + Mempool() mempool.Mempool }) require.True(t, ok) return n.Mempool() @@ -457,7 +457,7 @@ func TestBroadcastTxCommit(t *testing.T) { n, conf := NodeSuite(t) - mempool := getMempool(t, n) + pool := getMempool(t, n) for i, c := range GetClients(t, n, conf) { _, _, tx := MakeTxKV() bres, err := c.BroadcastTxCommit(ctx, tx) @@ -465,7 +465,7 @@ func TestBroadcastTxCommit(t *testing.T) { require.True(t, bres.CheckTx.IsOK()) require.True(t, bres.DeliverTx.IsOK()) - require.Equal(t, 0, mempool.Size()) + require.Equal(t, 0, pool.Size()) } } @@ -477,8 +477,8 @@ func TestUnconfirmedTxs(t *testing.T) { ch := make(chan *abci.Response, 1) n, conf := NodeSuite(t) - mempool := getMempool(t, n) - err := mempool.CheckTx(ctx, tx, func(resp *abci.Response) { ch <- resp }, mempl.TxInfo{}) + pool := getMempool(t, n) + err := pool.CheckTx(ctx, tx, func(resp *abci.Response) { ch <- resp }, mempool.TxInfo{}) require.NoError(t, err) @@ -497,11 +497,11 @@ func TestUnconfirmedTxs(t *testing.T) { assert.Equal(t, 1, res.Count) assert.Equal(t, 1, res.Total) - assert.Equal(t, mempool.SizeBytes(), res.TotalBytes) + assert.Equal(t, pool.SizeBytes(), res.TotalBytes) assert.Exactly(t, types.Txs{tx}, types.Txs(res.Txs)) } - mempool.Flush() + pool.Flush() } func TestNumUnconfirmedTxs(t *testing.T) { @@ -512,9 +512,9 @@ func TestNumUnconfirmedTxs(t *testing.T) { n, conf := NodeSuite(t) ch := make(chan *abci.Response, 1) - mempool := getMempool(t, n) + pool := getMempool(t, n) - err := mempool.CheckTx(ctx, tx, func(resp *abci.Response) { ch <- resp }, mempl.TxInfo{}) + err := pool.CheckTx(ctx, tx, func(resp *abci.Response) { ch <- resp }, mempool.TxInfo{}) require.NoError(t, err) // wait for tx to arrive in mempoool. @@ -524,7 +524,7 @@ func TestNumUnconfirmedTxs(t *testing.T) { t.Error("Timed out waiting for CheckTx callback") } - mempoolSize := mempool.Size() + mempoolSize := pool.Size() for i, c := range GetClients(t, n, conf) { mc, ok := c.(client.MempoolClient) require.True(t, ok, "%d", i) @@ -533,10 +533,10 @@ func TestNumUnconfirmedTxs(t *testing.T) { assert.Equal(t, mempoolSize, res.Count) assert.Equal(t, mempoolSize, res.Total) - assert.Equal(t, mempool.SizeBytes(), res.TotalBytes) + assert.Equal(t, pool.SizeBytes(), res.TotalBytes) } - mempool.Flush() + pool.Flush() } func TestCheckTx(t *testing.T) { @@ -544,7 +544,7 @@ func TestCheckTx(t *testing.T) { defer cancel() n, conf := NodeSuite(t) - mempool := getMempool(t, n) + pool := getMempool(t, n) for _, c := range GetClients(t, n, conf) { _, _, tx := MakeTxKV() @@ -553,7 +553,7 @@ func TestCheckTx(t *testing.T) { require.NoError(t, err) assert.Equal(t, abci.CodeTypeOK, res.Code) - assert.Equal(t, 0, mempool.Size(), "mempool must be empty") + assert.Equal(t, 0, pool.Size(), "mempool must be empty") } } @@ -781,10 +781,10 @@ func testBatchedJSONRPCCalls(ctx context.Context, t *testing.T, c *rpchttp.HTTP) require.Len(t, bresults, 2) require.Equal(t, 0, batch.Count()) - bresult1, ok := bresults[0].(*ctypes.ResultBroadcastTxCommit) + bresult1, ok := bresults[0].(*coretypes.ResultBroadcastTxCommit) require.True(t, ok) require.Equal(t, *bresult1, *r1) - bresult2, ok := bresults[1].(*ctypes.ResultBroadcastTxCommit) + bresult2, ok := bresults[1].(*coretypes.ResultBroadcastTxCommit) require.True(t, ok) require.Equal(t, *bresult2, *r2) apph := tmmath.MaxInt64(bresult1.Height, bresult2.Height) + 1 @@ -802,10 +802,10 @@ func testBatchedJSONRPCCalls(ctx context.Context, t *testing.T, c *rpchttp.HTTP) require.Len(t, qresults, 2) require.Equal(t, 0, batch.Count()) - qresult1, ok := qresults[0].(*ctypes.ResultABCIQuery) + qresult1, ok := qresults[0].(*coretypes.ResultABCIQuery) require.True(t, ok) require.Equal(t, *qresult1, *q1) - qresult2, ok := qresults[1].(*ctypes.ResultABCIQuery) + qresult2, ok := qresults[1].(*coretypes.ResultABCIQuery) require.True(t, ok) require.Equal(t, *qresult2, *q2) diff --git a/rpc/grpc/api.go b/rpc/grpc/api.go index 4db46bbe3..4a4a13687 100644 --- a/rpc/grpc/api.go +++ b/rpc/grpc/api.go @@ -4,7 +4,7 @@ import ( "context" abci "github.com/tendermint/tendermint/abci/types" - core "github.com/tendermint/tendermint/internal/rpc/core" + "github.com/tendermint/tendermint/internal/rpc/core" rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) diff --git a/rpc/grpc/grpc_test.go b/rpc/grpc/grpc_test.go index 45deb6b76..e680d195e 100644 --- a/rpc/grpc/grpc_test.go +++ b/rpc/grpc/grpc_test.go @@ -9,7 +9,7 @@ import ( "github.com/tendermint/tendermint/abci/example/kvstore" "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/libs/service" - core_grpc "github.com/tendermint/tendermint/rpc/grpc" + coregrpc "github.com/tendermint/tendermint/rpc/grpc" rpctest "github.com/tendermint/tendermint/rpc/test" ) @@ -37,7 +37,7 @@ func TestBroadcastTx(t *testing.T) { res, err := rpctest.GetGRPCClient(conf).BroadcastTx( context.Background(), - &core_grpc.RequestBroadcastTx{Tx: []byte("this is a tx")}, + &coregrpc.RequestBroadcastTx{Tx: []byte("this is a tx")}, ) require.NoError(t, err) require.EqualValues(t, 0, res.CheckTx.Code) diff --git a/rpc/jsonrpc/client/decode.go b/rpc/jsonrpc/client/decode.go index 42941ea68..f69926cb7 100644 --- a/rpc/jsonrpc/client/decode.go +++ b/rpc/jsonrpc/client/decode.go @@ -6,18 +6,18 @@ import ( "fmt" tmjson "github.com/tendermint/tendermint/libs/json" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) func unmarshalResponseBytes( responseBytes []byte, - expectedID types.JSONRPCIntID, + expectedID rpctypes.JSONRPCIntID, result interface{}, ) (interface{}, error) { // Read response. If rpc/core/types is imported, the result will unmarshal // into the correct type. - response := &types.RPCResponse{} + response := &rpctypes.RPCResponse{} if err := json.Unmarshal(responseBytes, response); err != nil { return nil, fmt.Errorf("error unmarshaling: %w", err) } @@ -40,12 +40,12 @@ func unmarshalResponseBytes( func unmarshalResponseBytesArray( responseBytes []byte, - expectedIDs []types.JSONRPCIntID, + expectedIDs []rpctypes.JSONRPCIntID, results []interface{}, ) ([]interface{}, error) { var ( - responses []types.RPCResponse + responses []rpctypes.RPCResponse ) if err := json.Unmarshal(responseBytes, &responses); err != nil { @@ -64,10 +64,10 @@ func unmarshalResponseBytesArray( } // Intersect IDs from responses with expectedIDs. - ids := make([]types.JSONRPCIntID, len(responses)) + ids := make([]rpctypes.JSONRPCIntID, len(responses)) var ok bool for i, resp := range responses { - ids[i], ok = resp.ID.(types.JSONRPCIntID) + ids[i], ok = resp.ID.(rpctypes.JSONRPCIntID) if !ok { return nil, fmt.Errorf("expected JSONRPCIntID, got %T", resp.ID) } @@ -85,8 +85,8 @@ func unmarshalResponseBytesArray( return results, nil } -func validateResponseIDs(ids, expectedIDs []types.JSONRPCIntID) error { - m := make(map[types.JSONRPCIntID]bool, len(expectedIDs)) +func validateResponseIDs(ids, expectedIDs []rpctypes.JSONRPCIntID) error { + m := make(map[rpctypes.JSONRPCIntID]bool, len(expectedIDs)) for _, expectedID := range expectedIDs { m[expectedID] = true } @@ -104,11 +104,11 @@ func validateResponseIDs(ids, expectedIDs []types.JSONRPCIntID) error { // From the JSON-RPC 2.0 spec: // id: It MUST be the same as the value of the id member in the Request Object. -func validateAndVerifyID(res *types.RPCResponse, expectedID types.JSONRPCIntID) error { +func validateAndVerifyID(res *rpctypes.RPCResponse, expectedID rpctypes.JSONRPCIntID) error { if err := validateResponseID(res.ID); err != nil { return err } - if expectedID != res.ID.(types.JSONRPCIntID) { // validateResponseID ensured res.ID has the right type + if expectedID != res.ID.(rpctypes.JSONRPCIntID) { // validateResponseID ensured res.ID has the right type return fmt.Errorf("response ID (%d) does not match request ID (%d)", res.ID, expectedID) } return nil @@ -118,7 +118,7 @@ func validateResponseID(id interface{}) error { if id == nil { return errors.New("no ID") } - _, ok := id.(types.JSONRPCIntID) + _, ok := id.(rpctypes.JSONRPCIntID) if !ok { return fmt.Errorf("expected JSONRPCIntID, but got: %T", id) } diff --git a/rpc/jsonrpc/client/http_json_client.go b/rpc/jsonrpc/client/http_json_client.go index 71c00137b..9c73b8a8c 100644 --- a/rpc/jsonrpc/client/http_json_client.go +++ b/rpc/jsonrpc/client/http_json_client.go @@ -13,7 +13,7 @@ import ( "time" tmsync "github.com/tendermint/tendermint/internal/libs/sync" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) const ( @@ -189,7 +189,7 @@ func (c *Client) Call( ) (interface{}, error) { id := c.nextRequestID() - request, err := types.MapToRequest(id, method, params) + request, err := rpctypes.MapToRequest(id, method, params) if err != nil { return nil, fmt.Errorf("failed to encode params: %w", err) } @@ -235,7 +235,7 @@ func (c *Client) NewRequestBatch() *RequestBatch { } func (c *Client) sendBatch(ctx context.Context, requests []*jsonRPCBufferedRequest) ([]interface{}, error) { - reqs := make([]types.RPCRequest, 0, len(requests)) + reqs := make([]rpctypes.RPCRequest, 0, len(requests)) results := make([]interface{}, 0, len(requests)) for _, req := range requests { reqs = append(reqs, req.request) @@ -272,20 +272,20 @@ func (c *Client) sendBatch(ctx context.Context, requests []*jsonRPCBufferedReque } // collect ids to check responses IDs in unmarshalResponseBytesArray - ids := make([]types.JSONRPCIntID, len(requests)) + ids := make([]rpctypes.JSONRPCIntID, len(requests)) for i, req := range requests { - ids[i] = req.request.ID.(types.JSONRPCIntID) + ids[i] = req.request.ID.(rpctypes.JSONRPCIntID) } return unmarshalResponseBytesArray(responseBytes, ids, results) } -func (c *Client) nextRequestID() types.JSONRPCIntID { +func (c *Client) nextRequestID() rpctypes.JSONRPCIntID { c.mtx.Lock() id := c.nextReqID c.nextReqID++ c.mtx.Unlock() - return types.JSONRPCIntID(id) + return rpctypes.JSONRPCIntID(id) } //------------------------------------------------------------------------------------ @@ -293,7 +293,7 @@ func (c *Client) nextRequestID() types.JSONRPCIntID { // jsonRPCBufferedRequest encapsulates a single buffered request, as well as its // anticipated response structure. type jsonRPCBufferedRequest struct { - request types.RPCRequest + request rpctypes.RPCRequest result interface{} // The result will be deserialized into this object. } @@ -354,7 +354,7 @@ func (b *RequestBatch) Call( result interface{}, ) (interface{}, error) { id := b.client.nextRequestID() - request, err := types.MapToRequest(id, method, params) + request, err := rpctypes.MapToRequest(id, method, params) if err != nil { return nil, err } diff --git a/rpc/jsonrpc/client/http_uri_client.go b/rpc/jsonrpc/client/http_uri_client.go index 3f376ddb0..cd4ff0686 100644 --- a/rpc/jsonrpc/client/http_uri_client.go +++ b/rpc/jsonrpc/client/http_uri_client.go @@ -7,12 +7,12 @@ import ( "net/http" "strings" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) const ( // URIClientRequestID in a request ID used by URIClient - URIClientRequestID = types.JSONRPCIntID(-1) + URIClientRequestID = rpctypes.JSONRPCIntID(-1) ) // URIClient is a JSON-RPC client, which sends POST form HTTP requests to the diff --git a/rpc/jsonrpc/client/ws_client.go b/rpc/jsonrpc/client/ws_client.go index 8530f32d9..8d8f9d18d 100644 --- a/rpc/jsonrpc/client/ws_client.go +++ b/rpc/jsonrpc/client/ws_client.go @@ -15,7 +15,7 @@ import ( tmsync "github.com/tendermint/tendermint/internal/libs/sync" tmclient "github.com/tendermint/tendermint/rpc/client" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) // WSOptions for WSClient. @@ -50,16 +50,16 @@ type WSClient struct { // nolint: maligned // Single user facing channel to read RPCResponses from, closed only when the // client is being stopped. - ResponsesCh chan types.RPCResponse + ResponsesCh chan rpctypes.RPCResponse // Callback, which will be called each time after successful reconnect. onReconnect func() // internal channels - send chan types.RPCRequest // user requests - backlog chan types.RPCRequest // stores a single user request received during a conn failure - reconnectAfter chan error // reconnect requests - readRoutineQuit chan struct{} // a way for readRoutine to close writeRoutine + send chan rpctypes.RPCRequest // user requests + backlog chan rpctypes.RPCRequest // stores a single user request received during a conn failure + reconnectAfter chan error // reconnect requests + readRoutineQuit chan struct{} // a way for readRoutine to close writeRoutine // Maximum reconnect attempts (0 or greater; default: 25). maxReconnectAttempts uint @@ -152,15 +152,15 @@ func (c *WSClient) Start() error { return err } - c.ResponsesCh = make(chan types.RPCResponse) + c.ResponsesCh = make(chan rpctypes.RPCResponse) - c.send = make(chan types.RPCRequest) + c.send = make(chan rpctypes.RPCRequest) // 1 additional error may come from the read/write // goroutine depending on which failed first. c.reconnectAfter = make(chan error, 1) // capacity for 1 request. a user won't be able to send more because the send // channel is unbuffered. - c.backlog = make(chan types.RPCRequest, 1) + c.backlog = make(chan rpctypes.RPCRequest, 1) c.startReadWriteRoutines() go c.reconnectRoutine() @@ -195,7 +195,7 @@ func (c *WSClient) IsActive() bool { // Send the given RPC request to the server. Results will be available on // ResponsesCh, errors, if any, on ErrorsCh. Will block until send succeeds or // ctx.Done is closed. -func (c *WSClient) Send(ctx context.Context, request types.RPCRequest) error { +func (c *WSClient) Send(ctx context.Context, request rpctypes.RPCRequest) error { select { case c.send <- request: c.Logger.Info("sent a request", "req", request) @@ -210,7 +210,7 @@ func (c *WSClient) Send(ctx context.Context, request types.RPCRequest) error { // Call enqueues a call request onto the Send queue. Requests are JSON encoded. func (c *WSClient) Call(ctx context.Context, method string, params map[string]interface{}) error { - request, err := types.MapToRequest(c.nextRequestID(), method, params) + request, err := rpctypes.MapToRequest(c.nextRequestID(), method, params) if err != nil { return err } @@ -220,7 +220,7 @@ func (c *WSClient) Call(ctx context.Context, method string, params map[string]in // CallWithArrayParams enqueues a call request onto the Send queue. Params are // in a form of array (e.g. []interface{}{"abcd"}). Requests are JSON encoded. func (c *WSClient) CallWithArrayParams(ctx context.Context, method string, params []interface{}) error { - request, err := types.ArrayToRequest(c.nextRequestID(), method, params) + request, err := rpctypes.ArrayToRequest(c.nextRequestID(), method, params) if err != nil { return err } @@ -229,12 +229,12 @@ func (c *WSClient) CallWithArrayParams(ctx context.Context, method string, param // Private methods -func (c *WSClient) nextRequestID() types.JSONRPCIntID { +func (c *WSClient) nextRequestID() rpctypes.JSONRPCIntID { c.mtx.Lock() id := c.nextReqID c.nextReqID++ c.mtx.Unlock() - return types.JSONRPCIntID(id) + return rpctypes.JSONRPCIntID(id) } func (c *WSClient) dial() error { @@ -462,7 +462,7 @@ func (c *WSClient) readRoutine() { return } - var response types.RPCResponse + var response rpctypes.RPCResponse err = json.Unmarshal(data, &response) if err != nil { c.Logger.Error("failed to parse response", "err", err, "data", string(data)) diff --git a/rpc/jsonrpc/client/ws_client_test.go b/rpc/jsonrpc/client/ws_client_test.go index bb8c149f6..208313e79 100644 --- a/rpc/jsonrpc/client/ws_client_test.go +++ b/rpc/jsonrpc/client/ws_client_test.go @@ -14,7 +14,7 @@ import ( tmsync "github.com/tendermint/tendermint/internal/libs/sync" "github.com/tendermint/tendermint/libs/log" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) var wsCallTimeout = 5 * time.Second @@ -41,7 +41,7 @@ func (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - var req types.RPCRequest + var req rpctypes.RPCRequest err = json.Unmarshal(in, &req) if err != nil { panic(err) @@ -56,7 +56,7 @@ func (h *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { h.mtx.RUnlock() res := json.RawMessage(`{}`) - emptyRespBytes, _ := json.Marshal(types.RPCResponse{Result: res, ID: req.ID}) + emptyRespBytes, _ := json.Marshal(rpctypes.RPCResponse{Result: res, ID: req.ID}) if err := conn.WriteMessage(messageType, emptyRespBytes); err != nil { return } diff --git a/rpc/jsonrpc/jsonrpc_test.go b/rpc/jsonrpc/jsonrpc_test.go index b5e422280..5013590b6 100644 --- a/rpc/jsonrpc/jsonrpc_test.go +++ b/rpc/jsonrpc/jsonrpc_test.go @@ -18,9 +18,9 @@ import ( tmbytes "github.com/tendermint/tendermint/libs/bytes" "github.com/tendermint/tendermint/libs/log" - client "github.com/tendermint/tendermint/rpc/jsonrpc/client" - server "github.com/tendermint/tendermint/rpc/jsonrpc/server" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + "github.com/tendermint/tendermint/rpc/jsonrpc/client" + "github.com/tendermint/tendermint/rpc/jsonrpc/server" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) // Client and Server should work over tcp or unix sockets @@ -64,23 +64,23 @@ var Routes = map[string]*server.RPCFunc{ "echo_int": server.NewRPCFunc(EchoIntResult, "arg", false), } -func EchoResult(ctx *types.Context, v string) (*ResultEcho, error) { +func EchoResult(ctx *rpctypes.Context, v string) (*ResultEcho, error) { return &ResultEcho{v}, nil } -func EchoWSResult(ctx *types.Context, v string) (*ResultEcho, error) { +func EchoWSResult(ctx *rpctypes.Context, v string) (*ResultEcho, error) { return &ResultEcho{v}, nil } -func EchoIntResult(ctx *types.Context, v int) (*ResultEchoInt, error) { +func EchoIntResult(ctx *rpctypes.Context, v int) (*ResultEchoInt, error) { return &ResultEchoInt{v}, nil } -func EchoBytesResult(ctx *types.Context, v []byte) (*ResultEchoBytes, error) { +func EchoBytesResult(ctx *rpctypes.Context, v []byte) (*ResultEchoBytes, error) { return &ResultEchoBytes{v}, nil } -func EchoDataBytesResult(ctx *types.Context, v tmbytes.HexBytes) (*ResultEchoDataBytes, error) { +func EchoDataBytesResult(ctx *rpctypes.Context, v tmbytes.HexBytes) (*ResultEchoDataBytes, error) { return &ResultEchoDataBytes{v}, nil } diff --git a/rpc/jsonrpc/server/http_json_handler.go b/rpc/jsonrpc/server/http_json_handler.go index 3e31d3ec1..fbc0cca79 100644 --- a/rpc/jsonrpc/server/http_json_handler.go +++ b/rpc/jsonrpc/server/http_json_handler.go @@ -12,8 +12,8 @@ import ( 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/jsonrpc/types" + "github.com/tendermint/tendermint/rpc/coretypes" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) // HTTP + JSON handler @@ -23,7 +23,7 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han return func(w http.ResponseWriter, r *http.Request) { b, err := ioutil.ReadAll(r.Body) if err != nil { - res := types.RPCInvalidRequestError(nil, + res := rpctypes.RPCInvalidRequestError(nil, fmt.Errorf("error reading request body: %w", err), ) if wErr := WriteRPCResponseHTTPError(w, res); wErr != nil { @@ -41,20 +41,20 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han // first try to unmarshal the incoming request as an array of RPC requests var ( - requests []types.RPCRequest - responses []types.RPCResponse + requests []rpctypes.RPCRequest + responses []rpctypes.RPCResponse ) if err := json.Unmarshal(b, &requests); err != nil { // next, try to unmarshal as a single request - var request types.RPCRequest + var request rpctypes.RPCRequest if err := json.Unmarshal(b, &request); err != nil { - res := types.RPCParseError(fmt.Errorf("error unmarshaling request: %w", err)) + res := rpctypes.RPCParseError(fmt.Errorf("error unmarshaling request: %w", err)) if wErr := WriteRPCResponseHTTPError(w, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } return } - requests = []types.RPCRequest{request} + requests = []rpctypes.RPCRequest{request} } // Set the default response cache to true unless @@ -77,25 +77,25 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han if len(r.URL.Path) > 1 { responses = append( responses, - types.RPCInvalidRequestError(request.ID, fmt.Errorf("path %s is invalid", r.URL.Path)), + rpctypes.RPCInvalidRequestError(request.ID, fmt.Errorf("path %s is invalid", r.URL.Path)), ) c = false continue } rpcFunc, ok := funcMap[request.Method] if !ok || rpcFunc.ws { - responses = append(responses, types.RPCMethodNotFoundError(request.ID)) + responses = append(responses, rpctypes.RPCMethodNotFoundError(request.ID)) c = false continue } - ctx := &types.Context{JSONReq: &request, HTTPReq: r} + ctx := &rpctypes.Context{JSONReq: &request, HTTPReq: r} args := []reflect.Value{reflect.ValueOf(ctx)} if len(request.Params) > 0 { fnArgs, err := jsonParamsToArgs(rpcFunc, request.Params) if err != nil { responses = append( responses, - types.RPCInvalidParamsError(request.ID, fmt.Errorf("error converting json params to arguments: %w", err)), + rpctypes.RPCInvalidParamsError(request.ID, fmt.Errorf("error converting json params to arguments: %w", err)), ) c = false continue @@ -114,22 +114,22 @@ func makeJSONRPCHandler(funcMap map[string]*RPCFunc, logger log.Logger) http.Han switch e := err.(type) { // if no error then return a success response case nil: - responses = append(responses, types.NewRPCSuccessResponse(request.ID, result)) + responses = append(responses, rpctypes.NewRPCSuccessResponse(request.ID, result)) // if this already of type RPC error then forward that error - case *types.RPCError: - responses = append(responses, types.NewRPCErrorResponse(request.ID, e.Code, e.Message, e.Data)) + case *rpctypes.RPCError: + responses = append(responses, rpctypes.NewRPCErrorResponse(request.ID, e.Code, e.Message, e.Data)) c = false default: // we need to unwrap the error and parse it accordingly switch errors.Unwrap(err) { // check if the error was due to an invald request - case ctypes.ErrZeroOrNegativeHeight, ctypes.ErrZeroOrNegativePerPage, - ctypes.ErrPageOutOfRange, ctypes.ErrInvalidRequest: - responses = append(responses, types.RPCInvalidRequestError(request.ID, err)) + case coretypes.ErrZeroOrNegativeHeight, coretypes.ErrZeroOrNegativePerPage, + coretypes.ErrPageOutOfRange, coretypes.ErrInvalidRequest: + responses = append(responses, rpctypes.RPCInvalidRequestError(request.ID, err)) c = false // lastly default all remaining errors as internal errors default: // includes ctypes.ErrHeightNotAvailable and ctypes.ErrHeightExceedsChainHead - responses = append(responses, types.RPCInternalError(request.ID, err)) + responses = append(responses, rpctypes.RPCInternalError(request.ID, err)) c = false } } @@ -277,7 +277,7 @@ func writeListOfEndpoints(w http.ResponseWriter, r *http.Request, funcMap map[st w.Write(buf.Bytes()) // nolint: errcheck } -func hasDefaultHeight(r types.RPCRequest, h []reflect.Value) bool { +func hasDefaultHeight(r rpctypes.RPCRequest, h []reflect.Value) bool { switch r.Method { case "block", "block_results", "commit", "consensus_params", "validators": return len(h) < 2 || h[1].IsZero() diff --git a/rpc/jsonrpc/server/http_json_handler_test.go b/rpc/jsonrpc/server/http_json_handler_test.go index 529f7619c..64e7597fd 100644 --- a/rpc/jsonrpc/server/http_json_handler_test.go +++ b/rpc/jsonrpc/server/http_json_handler_test.go @@ -12,13 +12,13 @@ import ( "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/libs/log" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) func testMux() *http.ServeMux { funcMap := map[string]*RPCFunc{ - "c": NewRPCFunc(func(ctx *types.Context, s string, i int) (string, error) { return "foo", nil }, "s,i", false), - "block": NewRPCFunc(func(ctx *types.Context, h int) (string, error) { return "block", nil }, "height", true), + "c": NewRPCFunc(func(ctx *rpctypes.Context, s string, i int) (string, error) { return "foo", nil }, "s,i", false), + "block": NewRPCFunc(func(ctx *rpctypes.Context, h int) (string, error) { return "block", nil }, "height", true), } mux := http.NewServeMux() logger := log.NewNopLogger() @@ -40,21 +40,21 @@ func TestRPCParams(t *testing.T) { expectedID interface{} }{ // bad - {`{"jsonrpc": "2.0", "id": "0"}`, "Method not found", types.JSONRPCStringID("0")}, - {`{"jsonrpc": "2.0", "method": "y", "id": "0"}`, "Method not found", types.JSONRPCStringID("0")}, + {`{"jsonrpc": "2.0", "id": "0"}`, "Method not found", rpctypes.JSONRPCStringID("0")}, + {`{"jsonrpc": "2.0", "method": "y", "id": "0"}`, "Method not found", rpctypes.JSONRPCStringID("0")}, // id not captured in JSON parsing failures {`{"method": "c", "id": "0", "params": a}`, "invalid character", nil}, - {`{"method": "c", "id": "0", "params": ["a"]}`, "got 1", types.JSONRPCStringID("0")}, - {`{"method": "c", "id": "0", "params": ["a", "b"]}`, "invalid character", types.JSONRPCStringID("0")}, - {`{"method": "c", "id": "0", "params": [1, 1]}`, "of type string", types.JSONRPCStringID("0")}, + {`{"method": "c", "id": "0", "params": ["a"]}`, "got 1", rpctypes.JSONRPCStringID("0")}, + {`{"method": "c", "id": "0", "params": ["a", "b"]}`, "invalid character", rpctypes.JSONRPCStringID("0")}, + {`{"method": "c", "id": "0", "params": [1, 1]}`, "of type string", rpctypes.JSONRPCStringID("0")}, // no ID - notification // {`{"jsonrpc": "2.0", "method": "c", "params": ["a", "10"]}`, false, nil}, // good - {`{"jsonrpc": "2.0", "method": "c", "id": "0", "params": null}`, "", types.JSONRPCStringID("0")}, - {`{"method": "c", "id": "0", "params": {}}`, "", types.JSONRPCStringID("0")}, - {`{"method": "c", "id": "0", "params": ["a", "10"]}`, "", types.JSONRPCStringID("0")}, + {`{"jsonrpc": "2.0", "method": "c", "id": "0", "params": null}`, "", rpctypes.JSONRPCStringID("0")}, + {`{"method": "c", "id": "0", "params": {}}`, "", rpctypes.JSONRPCStringID("0")}, + {`{"method": "c", "id": "0", "params": ["a", "10"]}`, "", rpctypes.JSONRPCStringID("0")}, } for i, tt := range tests { @@ -71,9 +71,9 @@ func TestRPCParams(t *testing.T) { continue } - recv := new(types.RPCResponse) + recv := new(rpctypes.RPCResponse) assert.Nil(t, json.Unmarshal(blob, recv), "#%d: expecting successful parsing of an RPCResponse:\nblob: %s", i, blob) - assert.NotEqual(t, recv, new(types.RPCResponse), "#%d: not expecting a blank RPCResponse", i) + assert.NotEqual(t, recv, new(rpctypes.RPCResponse), "#%d: not expecting a blank RPCResponse", i) assert.Equal(t, tt.expectedID, recv.ID, "#%d: expected ID not matched in RPCResponse", i) if tt.wantErr == "" { assert.Nil(t, recv.Error, "#%d: not expecting an error", i) @@ -93,12 +93,12 @@ func TestJSONRPCID(t *testing.T) { expectedID interface{} }{ // good id - {`{"jsonrpc": "2.0", "method": "c", "id": "0", "params": ["a", "10"]}`, false, types.JSONRPCStringID("0")}, - {`{"jsonrpc": "2.0", "method": "c", "id": "abc", "params": ["a", "10"]}`, false, types.JSONRPCStringID("abc")}, - {`{"jsonrpc": "2.0", "method": "c", "id": 0, "params": ["a", "10"]}`, false, types.JSONRPCIntID(0)}, - {`{"jsonrpc": "2.0", "method": "c", "id": 1, "params": ["a", "10"]}`, false, types.JSONRPCIntID(1)}, - {`{"jsonrpc": "2.0", "method": "c", "id": 1.3, "params": ["a", "10"]}`, false, types.JSONRPCIntID(1)}, - {`{"jsonrpc": "2.0", "method": "c", "id": -1, "params": ["a", "10"]}`, false, types.JSONRPCIntID(-1)}, + {`{"jsonrpc": "2.0", "method": "c", "id": "0", "params": ["a", "10"]}`, false, rpctypes.JSONRPCStringID("0")}, + {`{"jsonrpc": "2.0", "method": "c", "id": "abc", "params": ["a", "10"]}`, false, rpctypes.JSONRPCStringID("abc")}, + {`{"jsonrpc": "2.0", "method": "c", "id": 0, "params": ["a", "10"]}`, false, rpctypes.JSONRPCIntID(0)}, + {`{"jsonrpc": "2.0", "method": "c", "id": 1, "params": ["a", "10"]}`, false, rpctypes.JSONRPCIntID(1)}, + {`{"jsonrpc": "2.0", "method": "c", "id": 1.3, "params": ["a", "10"]}`, false, rpctypes.JSONRPCIntID(1)}, + {`{"jsonrpc": "2.0", "method": "c", "id": -1, "params": ["a", "10"]}`, false, rpctypes.JSONRPCIntID(-1)}, // bad id {`{"jsonrpc": "2.0", "method": "c", "id": {}, "params": ["a", "10"]}`, true, nil}, @@ -119,11 +119,11 @@ func TestJSONRPCID(t *testing.T) { } res.Body.Close() - recv := new(types.RPCResponse) + recv := new(rpctypes.RPCResponse) err = json.Unmarshal(blob, recv) assert.Nil(t, err, "#%d: expecting successful parsing of an RPCResponse:\nblob: %s", i, blob) if !tt.wantErr { - assert.NotEqual(t, recv, new(types.RPCResponse), "#%d: not expecting a blank RPCResponse", i) + assert.NotEqual(t, recv, new(rpctypes.RPCResponse), "#%d: not expecting a blank RPCResponse", i) assert.Equal(t, tt.expectedID, recv.ID, "#%d: expected ID not matched in RPCResponse", i) assert.Nil(t, recv.Error, "#%d: not expecting an error", i) } else { @@ -185,7 +185,7 @@ func TestRPCNotificationInBatch(t *testing.T) { } res.Body.Close() - var responses []types.RPCResponse + var responses []rpctypes.RPCResponse // try to unmarshal an array first err = json.Unmarshal(blob, &responses) if err != nil { @@ -195,14 +195,14 @@ func TestRPCNotificationInBatch(t *testing.T) { continue } else { // we were expecting an error here, so let's unmarshal a single response - var response types.RPCResponse + var response rpctypes.RPCResponse err = json.Unmarshal(blob, &response) if err != nil { t.Errorf("#%d: expected successful parsing of an RPCResponse\nblob: %s", i, blob) continue } // have a single-element result - responses = []types.RPCResponse{response} + responses = []rpctypes.RPCResponse{response} } } if tt.expectCount != len(responses) { @@ -210,7 +210,7 @@ func TestRPCNotificationInBatch(t *testing.T) { continue } for _, response := range responses { - assert.NotEqual(t, response, new(types.RPCResponse), "#%d: not expecting a blank RPCResponse", i) + assert.NotEqual(t, response, new(rpctypes.RPCResponse), "#%d: not expecting a blank RPCResponse", i) } } } diff --git a/rpc/jsonrpc/server/http_server.go b/rpc/jsonrpc/server/http_server.go index 549671241..49e1e510e 100644 --- a/rpc/jsonrpc/server/http_server.go +++ b/rpc/jsonrpc/server/http_server.go @@ -16,7 +16,7 @@ import ( "golang.org/x/net/netutil" "github.com/tendermint/tendermint/libs/log" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) // Config is a RPC server configuration. @@ -105,7 +105,7 @@ func ServeTLS( // source: https://www.jsonrpc.org/historical/json-rpc-over-http.html func WriteRPCResponseHTTPError( w http.ResponseWriter, - res types.RPCResponse, + res rpctypes.RPCResponse, ) error { if res.Error == nil { panic("tried to write http error response without RPC error") @@ -134,7 +134,7 @@ func WriteRPCResponseHTTPError( // WriteRPCResponseHTTP marshals res as JSON (with indent) and writes it to w. // If the rpc response can be cached, add cache-control to the response header. -func WriteRPCResponseHTTP(w http.ResponseWriter, c bool, res ...types.RPCResponse) error { +func WriteRPCResponseHTTP(w http.ResponseWriter, c bool, res ...rpctypes.RPCResponse) error { var v interface{} if len(res) == 1 { v = res[0] @@ -189,7 +189,7 @@ func RecoverAndLogHandler(handler http.Handler, logger log.Logger) http.Handler if e := recover(); e != nil { // If RPCResponse - if res, ok := e.(types.RPCResponse); ok { + if res, ok := e.(rpctypes.RPCResponse); ok { if wErr := WriteRPCResponseHTTP(rww, false, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } @@ -208,7 +208,7 @@ func RecoverAndLogHandler(handler http.Handler, logger log.Logger) http.Handler logger.Error("panic in RPC HTTP handler", "err", e, "stack", string(debug.Stack())) - res := types.RPCInternalError(types.JSONRPCIntID(-1), err) + res := rpctypes.RPCInternalError(rpctypes.JSONRPCIntID(-1), err) if wErr := WriteRPCResponseHTTPError(rww, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } diff --git a/rpc/jsonrpc/server/http_server_test.go b/rpc/jsonrpc/server/http_server_test.go index 823719e41..39e713565 100644 --- a/rpc/jsonrpc/server/http_server_test.go +++ b/rpc/jsonrpc/server/http_server_test.go @@ -17,7 +17,7 @@ import ( "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/libs/log" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) type sampleResult struct { @@ -107,11 +107,11 @@ func TestServeTLS(t *testing.T) { } func TestWriteRPCResponseHTTP(t *testing.T) { - id := types.JSONRPCIntID(-1) + id := rpctypes.JSONRPCIntID(-1) // one argument w := httptest.NewRecorder() - err := WriteRPCResponseHTTP(w, true, types.NewRPCSuccessResponse(id, &sampleResult{"hello"})) + err := WriteRPCResponseHTTP(w, true, rpctypes.NewRPCSuccessResponse(id, &sampleResult{"hello"})) require.NoError(t, err) resp := w.Result() body, err := ioutil.ReadAll(resp.Body) @@ -132,8 +132,8 @@ func TestWriteRPCResponseHTTP(t *testing.T) { w = httptest.NewRecorder() err = WriteRPCResponseHTTP(w, false, - types.NewRPCSuccessResponse(id, &sampleResult{"hello"}), - types.NewRPCSuccessResponse(id, &sampleResult{"world"})) + rpctypes.NewRPCSuccessResponse(id, &sampleResult{"hello"}), + rpctypes.NewRPCSuccessResponse(id, &sampleResult{"world"})) require.NoError(t, err) resp = w.Result() body, err = ioutil.ReadAll(resp.Body) @@ -162,7 +162,7 @@ func TestWriteRPCResponseHTTP(t *testing.T) { func TestWriteRPCResponseHTTPError(t *testing.T) { w := httptest.NewRecorder() - err := WriteRPCResponseHTTPError(w, types.RPCInternalError(types.JSONRPCIntID(-1), errors.New("foo"))) + err := WriteRPCResponseHTTPError(w, rpctypes.RPCInternalError(rpctypes.JSONRPCIntID(-1), errors.New("foo"))) require.NoError(t, err) resp := w.Result() body, err := ioutil.ReadAll(resp.Body) diff --git a/rpc/jsonrpc/server/http_uri_handler.go b/rpc/jsonrpc/server/http_uri_handler.go index a07401578..07b3616b4 100644 --- a/rpc/jsonrpc/server/http_uri_handler.go +++ b/rpc/jsonrpc/server/http_uri_handler.go @@ -11,8 +11,8 @@ import ( tmjson "github.com/tendermint/tendermint/libs/json" "github.com/tendermint/tendermint/libs/log" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + "github.com/tendermint/tendermint/rpc/coretypes" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) // HTTP + URI handler @@ -22,12 +22,12 @@ var reInt = regexp.MustCompile(`^-?[0-9]+$`) // convert from a function name to the http handler func makeHTTPHandler(rpcFunc *RPCFunc, logger log.Logger) func(http.ResponseWriter, *http.Request) { // Always return -1 as there's no ID here. - dummyID := types.JSONRPCIntID(-1) // URIClientRequestID + dummyID := rpctypes.JSONRPCIntID(-1) // URIClientRequestID // Exception for websocket endpoints if rpcFunc.ws { return func(w http.ResponseWriter, r *http.Request) { - res := types.RPCMethodNotFoundError(dummyID) + res := rpctypes.RPCMethodNotFoundError(dummyID) if wErr := WriteRPCResponseHTTPError(w, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } @@ -38,12 +38,12 @@ func makeHTTPHandler(rpcFunc *RPCFunc, logger log.Logger) func(http.ResponseWrit return func(w http.ResponseWriter, r *http.Request) { logger.Debug("HTTP HANDLER", "req", r) - ctx := &types.Context{HTTPReq: r} + ctx := &rpctypes.Context{HTTPReq: r} args := []reflect.Value{reflect.ValueOf(ctx)} fnArgs, err := httpParamsToArgs(rpcFunc, r) if err != nil { - res := types.RPCInvalidParamsError(dummyID, + res := rpctypes.RPCInvalidParamsError(dummyID, fmt.Errorf("error converting http params to arguments: %w", err), ) if wErr := WriteRPCResponseHTTPError(w, res); wErr != nil { @@ -60,29 +60,29 @@ func makeHTTPHandler(rpcFunc *RPCFunc, logger log.Logger) func(http.ResponseWrit switch e := err.(type) { // if no error then return a success response case nil: - res := types.NewRPCSuccessResponse(dummyID, result) + res := rpctypes.NewRPCSuccessResponse(dummyID, result) if wErr := WriteRPCResponseHTTP(w, rpcFunc.cache, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } // if this already of type RPC error then forward that error. - case *types.RPCError: - res := types.NewRPCErrorResponse(dummyID, e.Code, e.Message, e.Data) + case *rpctypes.RPCError: + res := rpctypes.NewRPCErrorResponse(dummyID, e.Code, e.Message, e.Data) if wErr := WriteRPCResponseHTTPError(w, res); wErr != nil { logger.Error("failed to write response", "res", res, "err", wErr) } default: // we need to unwrap the error and parse it accordingly - var res types.RPCResponse + var res rpctypes.RPCResponse switch errors.Unwrap(err) { - case ctypes.ErrZeroOrNegativeHeight, - ctypes.ErrZeroOrNegativePerPage, - ctypes.ErrPageOutOfRange, - ctypes.ErrInvalidRequest: - res = types.RPCInvalidRequestError(dummyID, err) + case coretypes.ErrZeroOrNegativeHeight, + coretypes.ErrZeroOrNegativePerPage, + coretypes.ErrPageOutOfRange, + coretypes.ErrInvalidRequest: + res = rpctypes.RPCInvalidRequestError(dummyID, err) default: // ctypes.ErrHeightNotAvailable, ctypes.ErrHeightExceedsChainHead: - res = types.RPCInternalError(dummyID, err) + res = rpctypes.RPCInternalError(dummyID, err) } if wErr := WriteRPCResponseHTTPError(w, res); wErr != nil { diff --git a/rpc/jsonrpc/server/parse_test.go b/rpc/jsonrpc/server/parse_test.go index 86316f8e5..92ea6f2c0 100644 --- a/rpc/jsonrpc/server/parse_test.go +++ b/rpc/jsonrpc/server/parse_test.go @@ -10,7 +10,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/tendermint/tendermint/libs/bytes" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) func TestParseJSONMap(t *testing.T) { @@ -134,7 +134,7 @@ func TestParseJSONArray(t *testing.T) { } func TestParseJSONRPC(t *testing.T) { - demo := func(ctx *types.Context, height int, name string) {} + demo := func(ctx *rpctypes.Context, height int, name string) {} call := NewRPCFunc(demo, "height,name", false) cases := []struct { @@ -171,7 +171,7 @@ func TestParseJSONRPC(t *testing.T) { } func TestParseURI(t *testing.T) { - demo := func(ctx *types.Context, height int, name string) {} + demo := func(ctx *rpctypes.Context, height int, name string) {} call := NewRPCFunc(demo, "height,name", false) cases := []struct { diff --git a/rpc/jsonrpc/server/ws_handler.go b/rpc/jsonrpc/server/ws_handler.go index 63731799b..2271d03f8 100644 --- a/rpc/jsonrpc/server/ws_handler.go +++ b/rpc/jsonrpc/server/ws_handler.go @@ -14,8 +14,8 @@ import ( "github.com/tendermint/tendermint/libs/log" "github.com/tendermint/tendermint/rpc/client" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + "github.com/tendermint/tendermint/rpc/coretypes" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) // WebSocket handler @@ -111,7 +111,7 @@ type wsConnection struct { remoteAddr string baseConn *websocket.Conn // writeChan is never closed, to allow WriteRPCResponse() to fail. - writeChan chan types.RPCResponse + writeChan chan rpctypes.RPCResponse // chan, which is closed when/if readRoutine errors // used to abort writeRoutine @@ -224,7 +224,7 @@ func (wsc *wsConnection) Start() error { if err := wsc.RunState.Start(); err != nil { return err } - wsc.writeChan = make(chan types.RPCResponse, wsc.writeChanCapacity) + wsc.writeChan = make(chan rpctypes.RPCResponse, wsc.writeChanCapacity) // Read subscriptions/unsubscriptions to events go wsc.readRoutine() @@ -257,7 +257,7 @@ func (wsc *wsConnection) GetRemoteAddr() string { // WriteRPCResponse pushes a response to the writeChan, and blocks until it is // accepted. // It implements WSRPCConnection. It is Goroutine-safe. -func (wsc *wsConnection) WriteRPCResponse(ctx context.Context, resp types.RPCResponse) error { +func (wsc *wsConnection) WriteRPCResponse(ctx context.Context, resp rpctypes.RPCResponse) error { select { case <-wsc.Quit(): return errors.New("connection was stopped") @@ -271,7 +271,7 @@ func (wsc *wsConnection) WriteRPCResponse(ctx context.Context, resp types.RPCRes // TryWriteRPCResponse attempts to push a response to the writeChan, but does // not block. // It implements WSRPCConnection. It is Goroutine-safe -func (wsc *wsConnection) TryWriteRPCResponse(resp types.RPCResponse) bool { +func (wsc *wsConnection) TryWriteRPCResponse(resp rpctypes.RPCResponse) bool { select { case <-wsc.Quit(): return false @@ -304,7 +304,7 @@ func (wsc *wsConnection) readRoutine() { err = fmt.Errorf("WSJSONRPC: %v", r) } wsc.Logger.Error("Panic in WSJSONRPC handler", "err", err, "stack", string(debug.Stack())) - if err := wsc.WriteRPCResponse(writeCtx, types.RPCInternalError(types.JSONRPCIntID(-1), err)); err != nil { + if err := wsc.WriteRPCResponse(writeCtx, rpctypes.RPCInternalError(rpctypes.JSONRPCIntID(-1), err)); err != nil { wsc.Logger.Error("Error writing RPC response", "err", err) } go wsc.readRoutine() @@ -340,11 +340,11 @@ func (wsc *wsConnection) readRoutine() { } dec := json.NewDecoder(r) - var request types.RPCRequest + var request rpctypes.RPCRequest err = dec.Decode(&request) if err != nil { if err := wsc.WriteRPCResponse(writeCtx, - types.RPCParseError(fmt.Errorf("error unmarshaling request: %w", err))); err != nil { + rpctypes.RPCParseError(fmt.Errorf("error unmarshaling request: %w", err))); err != nil { wsc.Logger.Error("Error writing RPC response", "err", err) } continue @@ -363,19 +363,19 @@ func (wsc *wsConnection) readRoutine() { // Now, fetch the RPCFunc and execute it. rpcFunc := wsc.funcMap[request.Method] if rpcFunc == nil { - if err := wsc.WriteRPCResponse(writeCtx, types.RPCMethodNotFoundError(request.ID)); err != nil { + if err := wsc.WriteRPCResponse(writeCtx, rpctypes.RPCMethodNotFoundError(request.ID)); err != nil { wsc.Logger.Error("Error writing RPC response", "err", err) } continue } - ctx := &types.Context{JSONReq: &request, WSConn: wsc} + ctx := &rpctypes.Context{JSONReq: &request, WSConn: wsc} args := []reflect.Value{reflect.ValueOf(ctx)} if len(request.Params) > 0 { fnArgs, err := jsonParamsToArgs(rpcFunc, request.Params) if err != nil { if err := wsc.WriteRPCResponse(writeCtx, - types.RPCInvalidParamsError(request.ID, fmt.Errorf("error converting json params to arguments: %w", err)), + rpctypes.RPCInvalidParamsError(request.ID, fmt.Errorf("error converting json params to arguments: %w", err)), ); err != nil { wsc.Logger.Error("Error writing RPC response", "err", err) } @@ -389,27 +389,27 @@ func (wsc *wsConnection) readRoutine() { // TODO: Need to encode args/returns to string if we want to log them wsc.Logger.Info("WSJSONRPC", "method", request.Method) - var resp types.RPCResponse + var resp rpctypes.RPCResponse result, err := unreflectResult(returns) switch e := err.(type) { // if no error then return a success response case nil: - resp = types.NewRPCSuccessResponse(request.ID, result) + resp = rpctypes.NewRPCSuccessResponse(request.ID, result) // if this already of type RPC error then forward that error - case *types.RPCError: - resp = types.NewRPCErrorResponse(request.ID, e.Code, e.Message, e.Data) + case *rpctypes.RPCError: + resp = rpctypes.NewRPCErrorResponse(request.ID, e.Code, e.Message, e.Data) default: // we need to unwrap the error and parse it accordingly switch errors.Unwrap(err) { // check if the error was due to an invald request - case ctypes.ErrZeroOrNegativeHeight, ctypes.ErrZeroOrNegativePerPage, - ctypes.ErrPageOutOfRange, ctypes.ErrInvalidRequest: - resp = types.RPCInvalidRequestError(request.ID, err) + case coretypes.ErrZeroOrNegativeHeight, coretypes.ErrZeroOrNegativePerPage, + coretypes.ErrPageOutOfRange, coretypes.ErrInvalidRequest: + resp = rpctypes.RPCInvalidRequestError(request.ID, err) // lastly default all remaining errors as internal errors default: // includes ctypes.ErrHeightNotAvailable and ctypes.ErrHeightExceedsChainHead - resp = types.RPCInternalError(request.ID, err) + resp = rpctypes.RPCInternalError(request.ID, err) } } diff --git a/rpc/jsonrpc/server/ws_handler_test.go b/rpc/jsonrpc/server/ws_handler_test.go index 42a96d1d3..b691172a4 100644 --- a/rpc/jsonrpc/server/ws_handler_test.go +++ b/rpc/jsonrpc/server/ws_handler_test.go @@ -9,7 +9,7 @@ import ( "github.com/stretchr/testify/require" "github.com/tendermint/tendermint/libs/log" - types "github.com/tendermint/tendermint/rpc/jsonrpc/types" + rpctypes "github.com/tendermint/tendermint/rpc/jsonrpc/types" ) func TestWebsocketManagerHandler(t *testing.T) { @@ -26,8 +26,8 @@ func TestWebsocketManagerHandler(t *testing.T) { } // check basic functionality works - req, err := types.MapToRequest( - types.JSONRPCStringID("TestWebsocketManager"), + req, err := rpctypes.MapToRequest( + rpctypes.JSONRPCStringID("TestWebsocketManager"), "c", map[string]interface{}{"s": "a", "i": 10}, ) @@ -35,7 +35,7 @@ func TestWebsocketManagerHandler(t *testing.T) { err = c.WriteJSON(req) require.NoError(t, err) - var resp types.RPCResponse + var resp rpctypes.RPCResponse err = c.ReadJSON(&resp) require.NoError(t, err) require.Nil(t, resp.Error) @@ -44,7 +44,7 @@ func TestWebsocketManagerHandler(t *testing.T) { func newWSServer() *httptest.Server { funcMap := map[string]*RPCFunc{ - "c": NewWSRPCFunc(func(ctx *types.Context, s string, i int) (string, error) { return "foo", nil }, "s,i"), + "c": NewWSRPCFunc(func(ctx *rpctypes.Context, s string, i int) (string, error) { return "foo", nil }, "s,i"), } wm := NewWebsocketManager(funcMap) wm.SetLogger(log.TestingLogger()) diff --git a/rpc/test/helpers.go b/rpc/test/helpers.go index 91cff8386..01aa83b4f 100644 --- a/rpc/test/helpers.go +++ b/rpc/test/helpers.go @@ -8,13 +8,13 @@ import ( abciclient "github.com/tendermint/tendermint/abci/client" abci "github.com/tendermint/tendermint/abci/types" - cfg "github.com/tendermint/tendermint/config" + "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" - ctypes "github.com/tendermint/tendermint/rpc/coretypes" - core_grpc "github.com/tendermint/tendermint/rpc/grpc" + "github.com/tendermint/tendermint/node" + "github.com/tendermint/tendermint/rpc/coretypes" + coregrpc "github.com/tendermint/tendermint/rpc/grpc" rpcclient "github.com/tendermint/tendermint/rpc/jsonrpc/client" ) @@ -24,13 +24,13 @@ type Options struct { suppressStdout bool } -func waitForRPC(ctx context.Context, conf *cfg.Config) { +func waitForRPC(ctx context.Context, conf *config.Config) { laddr := conf.RPC.ListenAddress client, err := rpcclient.New(laddr) if err != nil { panic(err) } - result := new(ctypes.ResultStatus) + result := new(coretypes.ResultStatus) for { _, err := client.Call(ctx, "status", map[string]interface{}{}, result) if err == nil { @@ -42,10 +42,10 @@ func waitForRPC(ctx context.Context, conf *cfg.Config) { } } -func waitForGRPC(ctx context.Context, conf *cfg.Config) { +func waitForGRPC(ctx context.Context, conf *config.Config) { client := GetGRPCClient(conf) for { - _, err := client.Ping(ctx, &core_grpc.RequestPing{}) + _, err := client.Ping(ctx, &coregrpc.RequestPing{}) if err == nil { return } @@ -66,8 +66,8 @@ func makeAddrs() (string, string, string) { fmt.Sprintf("tcp://127.0.0.1:%d", randPort()) } -func CreateConfig(testName string) *cfg.Config { - c := cfg.ResetTestRoot(testName) +func CreateConfig(testName string) *config.Config { + c := config.ResetTestRoot(testName) // and we use random ports to run in parallel tm, rpc, grpc := makeAddrs() @@ -78,15 +78,15 @@ func CreateConfig(testName string) *cfg.Config { return c } -func GetGRPCClient(conf *cfg.Config) core_grpc.BroadcastAPIClient { +func GetGRPCClient(conf *config.Config) coregrpc.BroadcastAPIClient { grpcAddr := conf.RPC.GRPCListenAddress - return core_grpc.StartGRPCClient(grpcAddr) + return coregrpc.StartGRPCClient(grpcAddr) } type ServiceCloser func(context.Context) error func StartTendermint(ctx context.Context, - conf *cfg.Config, + conf *config.Config, app abci.Application, opts ...func(*Options)) (service.Service, ServiceCloser, error) { @@ -101,12 +101,12 @@ func StartTendermint(ctx context.Context, logger = log.MustNewDefaultLogger(log.LogFormatPlain, log.LogLevelInfo, false) } papp := abciclient.NewLocalCreator(app) - node, err := nm.New(conf, logger, papp, nil) + tmNode, err := node.New(conf, logger, papp, nil) if err != nil { return nil, func(_ context.Context) error { return nil }, err } - err = node.Start() + err = tmNode.Start() if err != nil { return nil, func(_ context.Context) error { return nil }, err } @@ -119,11 +119,11 @@ func StartTendermint(ctx context.Context, fmt.Println("Tendermint running!") } - return node, func(ctx context.Context) error { - if err := node.Stop(); err != nil { + return tmNode, func(ctx context.Context) error { + if err := tmNode.Stop(); err != nil { logger.Error("Error when trying to stop node", "err", err) } - node.Wait() + tmNode.Wait() os.RemoveAll(conf.RootDir) return nil }, nil diff --git a/scripts/json2wal/main.go b/scripts/json2wal/main.go index d21dc6c44..6b60ac2fc 100644 --- a/scripts/json2wal/main.go +++ b/scripts/json2wal/main.go @@ -14,7 +14,7 @@ import ( "os" "strings" - cs "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/consensus" tmjson "github.com/tendermint/tendermint/libs/json" "github.com/tendermint/tendermint/types" ) @@ -41,7 +41,7 @@ func main() { // because of the byte array in BlockPart // leading to unmarshal error: unexpected end of JSON input br := bufio.NewReaderSize(f, int(2*types.BlockPartSizeBytes)) - dec := cs.NewWALEncoder(walFile) + dec := consensus.NewWALEncoder(walFile) for { msgJSON, _, err := br.ReadLine() @@ -55,7 +55,7 @@ func main() { continue } - var msg cs.TimedWALMessage + var msg consensus.TimedWALMessage err = tmjson.Unmarshal(msgJSON, &msg) if err != nil { panic(fmt.Errorf("failed to unmarshal json: %v", err)) diff --git a/scripts/wal2json/main.go b/scripts/wal2json/main.go index 886e5402f..5a5a0abac 100644 --- a/scripts/wal2json/main.go +++ b/scripts/wal2json/main.go @@ -12,7 +12,7 @@ import ( "io" "os" - cs "github.com/tendermint/tendermint/internal/consensus" + "github.com/tendermint/tendermint/internal/consensus" tmjson "github.com/tendermint/tendermint/libs/json" ) @@ -28,7 +28,7 @@ func main() { } defer f.Close() - dec := cs.NewWALDecoder(f) + dec := consensus.NewWALDecoder(f) for { msg, err := dec.Decode() if err == io.EOF { @@ -48,7 +48,7 @@ func main() { } if err == nil { - if endMsg, ok := msg.Msg.(cs.EndHeightMessage); ok { + if endMsg, ok := msg.Msg.(consensus.EndHeightMessage); ok { _, err = os.Stdout.Write([]byte(fmt.Sprintf("ENDHEIGHT %d\n", endMsg.Height))) } } diff --git a/store/store_test.go b/store/store_test.go index e00715eb7..03db91fa8 100644 --- a/store/store_test.go +++ b/store/store_test.go @@ -12,7 +12,7 @@ import ( "github.com/stretchr/testify/require" dbm "github.com/tendermint/tm-db" - cfg "github.com/tendermint/tendermint/config" + "github.com/tendermint/tendermint/config" "github.com/tendermint/tendermint/crypto" sm "github.com/tendermint/tendermint/internal/state" "github.com/tendermint/tendermint/internal/state/test/factory" @@ -46,13 +46,13 @@ func makeTestCommit(height int64, timestamp time.Time) *types.Commit { } func makeStateAndBlockStore(logger log.Logger) (sm.State, *BlockStore, cleanupFunc) { - config := cfg.ResetTestRoot("blockchain_reactor_test") + cfg := config.ResetTestRoot("blockchain_reactor_test") blockDB := dbm.NewMemDB() - state, err := sm.MakeGenesisStateFromFile(config.GenesisFile()) + state, err := sm.MakeGenesisStateFromFile(cfg.GenesisFile()) if err != nil { panic(fmt.Errorf("error constructing state from genesis file: %w", err)) } - return state, NewBlockStore(blockDB), func() { os.RemoveAll(config.RootDir) } + return state, NewBlockStore(blockDB), func() { os.RemoveAll(cfg.RootDir) } } func freshBlockStore() (*BlockStore, dbm.DB) { @@ -292,9 +292,9 @@ func TestBlockStoreSaveLoadBlock(t *testing.T) { } func TestLoadBaseMeta(t *testing.T) { - config := cfg.ResetTestRoot("blockchain_reactor_test") - defer os.RemoveAll(config.RootDir) - state, err := sm.MakeGenesisStateFromFile(config.GenesisFile()) + cfg := config.ResetTestRoot("blockchain_reactor_test") + defer os.RemoveAll(cfg.RootDir) + state, err := sm.MakeGenesisStateFromFile(cfg.GenesisFile()) require.NoError(t, err) bs := NewBlockStore(dbm.NewMemDB()) @@ -348,9 +348,9 @@ func TestLoadBlockPart(t *testing.T) { } func TestPruneBlocks(t *testing.T) { - config := cfg.ResetTestRoot("blockchain_reactor_test") - defer os.RemoveAll(config.RootDir) - state, err := sm.MakeGenesisStateFromFile(config.GenesisFile()) + cfg := config.ResetTestRoot("blockchain_reactor_test") + defer os.RemoveAll(cfg.RootDir) + state, err := sm.MakeGenesisStateFromFile(cfg.GenesisFile()) require.NoError(t, err) db := dbm.NewMemDB() bs := NewBlockStore(db) diff --git a/types/protobuf.go b/types/protobuf.go index 7cd224665..f82965fbf 100644 --- a/types/protobuf.go +++ b/types/protobuf.go @@ -2,7 +2,7 @@ package types import ( abci "github.com/tendermint/tendermint/abci/types" - cryptoenc "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" ) //------------------------------------------------------- @@ -22,7 +22,7 @@ func (tm2pb) Validator(val *Validator) abci.Validator { // XXX: panics on unknown pubkey type func (tm2pb) ValidatorUpdate(val *Validator) abci.ValidatorUpdate { - pk, err := cryptoenc.PubKeyToProto(val.PubKey) + pk, err := encoding.PubKeyToProto(val.PubKey) if err != nil { panic(err) } @@ -52,7 +52,7 @@ type pb2tm struct{} func (pb2tm) ValidatorUpdates(vals []abci.ValidatorUpdate) ([]*Validator, error) { tmVals := make([]*Validator, len(vals)) for i, v := range vals { - pub, err := cryptoenc.PubKeyFromProto(v.PubKey) + pub, err := encoding.PubKeyFromProto(v.PubKey) if err != nil { return nil, err } diff --git a/types/protobuf_test.go b/types/protobuf_test.go index b6900f40c..a33d031e2 100644 --- a/types/protobuf_test.go +++ b/types/protobuf_test.go @@ -9,7 +9,7 @@ import ( 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/encoding" ) func TestABCIPubKey(t *testing.T) { @@ -19,9 +19,9 @@ func TestABCIPubKey(t *testing.T) { } func testABCIPubKey(t *testing.T, pk crypto.PubKey, typeStr string) error { - abciPubKey, err := cryptoenc.PubKeyToProto(pk) + abciPubKey, err := encoding.PubKeyToProto(pk) require.NoError(t, err) - pk2, err := cryptoenc.PubKeyFromProto(abciPubKey) + pk2, err := encoding.PubKeyFromProto(abciPubKey) require.NoError(t, err) require.Equal(t, pk, pk2) return nil diff --git a/types/validator.go b/types/validator.go index fb3fa2d76..ded8156bf 100644 --- a/types/validator.go +++ b/types/validator.go @@ -7,7 +7,7 @@ import ( "strings" "github.com/tendermint/tendermint/crypto" - ce "github.com/tendermint/tendermint/crypto/encoding" + "github.com/tendermint/tendermint/crypto/encoding" tmproto "github.com/tendermint/tendermint/proto/tendermint/types" ) @@ -114,7 +114,7 @@ func ValidatorListString(vals []*Validator) string { // as its redundant with the pubkey. This also excludes ProposerPriority // which changes every round. func (v *Validator) Bytes() []byte { - pk, err := ce.PubKeyToProto(v.PubKey) + pk, err := encoding.PubKeyToProto(v.PubKey) if err != nil { panic(err) } @@ -137,7 +137,7 @@ func (v *Validator) ToProto() (*tmproto.Validator, error) { return nil, errors.New("nil validator") } - pk, err := ce.PubKeyToProto(v.PubKey) + pk, err := encoding.PubKeyToProto(v.PubKey) if err != nil { return nil, err } @@ -159,7 +159,7 @@ func ValidatorFromProto(vp *tmproto.Validator) (*Validator, error) { return nil, errors.New("nil validator") } - pk, err := ce.PubKeyFromProto(vp.PubKey) + pk, err := encoding.PubKeyFromProto(vp.PubKey) if err != nil { return nil, err }