Migrate {x/auth, x/gov, x/staking} missing CLI queries to proto

proto/cosmos/base/abci/v1beta1/abci.proto

@@ -114,3 +114,30 @@ message TxMsgData {
 
   repeated MsgData data = 1;
 }
+
+// SearchTxsResult defines a structure for querying txs pageable
+message SearchTxsResult {
+  option (gogoproto.stringer) = true;
+
+  // Count of all txs
+  uint64 total_count = 1 [
+    (gogoproto.moretags)   = "yaml:\"total_count\"",
+    (gogoproto.jsontag)   = "total_count"
+  ];
+  // Count of txs in current page
+  uint64 count = 2;
+  // Index of current page, start from 1
+  uint64 page_number = 3 [
+    (gogoproto.moretags)   = "yaml:\"page_number\"",
+    (gogoproto.jsontag)   = "page_number"
+  ];
+  // Count of total pages
+  uint64 page_total = 4 [
+    (gogoproto.moretags)   = "yaml:\"page_total\"",
+    (gogoproto.jsontag)   = "page_total"
+  ];
+  // Max count txs per page
+  uint64 limit = 5;
+  // List of txs in current page
+  repeated TxResponse txs = 6;
+}

types/result.go

@@ -213,22 +213,12 @@ func (r TxResponse) Empty() bool {
 	return r.TxHash == "" && r.Logs == nil
 }
 
-// SearchTxsResult defines a structure for querying txs pageable
-type SearchTxsResult struct {
-	TotalCount int           `json:"total_count"` // Count of all txs
-	Count      int           `json:"count"`       // Count of txs in current page
-	PageNumber int           `json:"page_number"` // Index of current page, start from 1
-	PageTotal  int           `json:"page_total"`  // Count of total pages
-	Limit      int           `json:"limit"`       // Max count txs per page
-	Txs        []*TxResponse `json:"txs"`         // List of txs in current page
-}
-
-func NewSearchTxsResult(totalCount, count, page, limit int, txs []*TxResponse) SearchTxsResult {
-	return SearchTxsResult{
+func NewSearchTxsResult(totalCount, count, page, limit uint64, txs []*TxResponse) *SearchTxsResult {
+	return &SearchTxsResult{
 		TotalCount: totalCount,
 		Count:      count,
 		PageNumber: page,
-		PageTotal:  int(math.Ceil(float64(totalCount) / float64(limit))),
+		PageTotal:  uint64(math.Ceil(float64(totalCount) / float64(limit))),
 		Limit:      limit,
 		Txs:        txs,
 	}

types/result_test.go

@@ -41,7 +41,7 @@ func TestABCIMessageLog(t *testing.T) {
 func TestNewSearchTxsResult(t *testing.T) {
 	t.Parallel()
 	got := sdk.NewSearchTxsResult(150, 20, 2, 20, []*sdk.TxResponse{})
-	require.Equal(t, sdk.SearchTxsResult{
+	require.Equal(t, &sdk.SearchTxsResult{
 		TotalCount: 150,
 		Count:      20,
 		PageNumber: 2,

x/auth/client/cli/cli_test.go

@@ -8,8 +8,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/cosmos/cosmos-sdk/codec/types"
-
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
 	tmcrypto "github.com/tendermint/tendermint/crypto"
@@ -18,6 +16,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	codec2 "github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/codec/types"
 	"github.com/cosmos/cosmos-sdk/crypto/hd"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 	"github.com/cosmos/cosmos-sdk/crypto/types/multisig"
@@ -165,6 +164,47 @@ func (s *IntegrationTestSuite) TestCLISignBatch() {
 	s.Require().Error(err)
 }
 
+func (s *IntegrationTestSuite) TestCLITxQueryCmd() {
+	val := s.network.Validators[0]
+	var txHash string
+
+	s.Run("bank send tx", func() {
+		clientCtx := val.ClientCtx
+
+		bz, err := bankcli.MsgSendExec(clientCtx, val.Address, val.Address, sdk.NewCoins(
+			sdk.NewCoin(fmt.Sprintf("%stoken", val.Moniker), sdk.NewInt(10)),
+			sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10)),
+		), []string{
+			fmt.Sprintf("--%s=true", flags.FlagSkipConfirmation),
+			fmt.Sprintf("--%s=%s", flags.FlagBroadcastMode, flags.BroadcastBlock),
+			fmt.Sprintf("--%s=%s", flags.FlagFees, sdk.NewCoins(sdk.NewCoin(s.cfg.BondDenom, sdk.NewInt(10))).String()),
+		}...)
+
+		var txRes sdk.TxResponse
+		s.Require().NoError(err)
+		s.Require().NoError(clientCtx.JSONMarshaler.UnmarshalJSON(bz.Bytes(), &txRes), bz.String())
+
+		txHash = txRes.TxHash
+		s.Require().Equal(uint32(0), txRes.Code)
+	})
+
+	s.network.WaitForNextBlock()
+
+	s.Run("", func() {
+		cmd := authcli.QueryTxCmd()
+		args := []string{
+			txHash,
+		}
+
+		out, err := clitestutil.ExecTestCLICmd(val.ClientCtx, cmd, args)
+		s.Require().NoError(err)
+
+		var tx sdk.TxResponse
+		s.Require().NoError(val.ClientCtx.JSONMarshaler.UnmarshalJSON(out.Bytes(), &tx))
+		fmt.Println(tx)
+	})
+}
+
 func (s *IntegrationTestSuite) TestCLISendGenerateSignAndBroadcast() {
 	val1 := s.network.Validators[0]
 

x/auth/client/cli/query.go

@@ -167,13 +167,7 @@ $ %s query txs --%s 'message.sender=cosmos1...&message.action=withdraw_delegator
 				return err
 			}
 
-			output, err := clientCtx.LegacyAmino.MarshalJSON(txs)
-			if err != nil {
-				return err
-			}
-
-			fmt.Println(string(output))
-			return nil
+			return clientCtx.PrintOutput(txs)
 		},
 	}
 

x/auth/client/query.go

@@ -9,9 +9,7 @@ import (
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 
 	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
-	"github.com/cosmos/cosmos-sdk/x/auth/types"
 )
 
 // QueryTxsByEvents performs a search for transactions for a given set of events
@@ -53,14 +51,14 @@ func QueryTxsByEvents(clientCtx client.Context, events []string, page, limit int
 		return nil, err
 	}
 
-	txs, err := formatTxResults(clientCtx.LegacyAmino, resTxs.Txs, resBlocks)
+	txs, err := formatTxResults(clientCtx.TxConfig, resTxs.Txs, resBlocks)
 	if err != nil {
 		return nil, err
 	}
 
-	result := sdk.NewSearchTxsResult(resTxs.TotalCount, len(txs), page, limit, txs)
+	result := sdk.NewSearchTxsResult(uint64(resTxs.TotalCount), uint64(len(txs)), uint64(page), uint64(limit), txs)
 
-	return &result, nil
+	return result, nil
 }
 
 // QueryTx queries for a single transaction by a hash string in hex format. An
@@ -88,7 +86,7 @@ func QueryTx(clientCtx client.Context, hashHexStr string) (*sdk.TxResponse, erro
 		return nil, err
 	}
 
-	out, err := formatTxResult(clientCtx.LegacyAmino, resTx, resBlocks[resTx.Height])
+	out, err := formatTxResult(clientCtx.TxConfig, resTx, resBlocks[resTx.Height])
 	if err != nil {
 		return out, err
 	}
@@ -97,11 +95,11 @@ func QueryTx(clientCtx client.Context, hashHexStr string) (*sdk.TxResponse, erro
 }
 
 // formatTxResults parses the indexed txs into a slice of TxResponse objects.
-func formatTxResults(cdc *codec.LegacyAmino, resTxs []*ctypes.ResultTx, resBlocks map[int64]*ctypes.ResultBlock) ([]*sdk.TxResponse, error) {
+func formatTxResults(txConfig client.TxConfig, resTxs []*ctypes.ResultTx, resBlocks map[int64]*ctypes.ResultBlock) ([]*sdk.TxResponse, error) {
 	var err error
 	out := make([]*sdk.TxResponse, len(resTxs))
 	for i := range resTxs {
-		out[i], err = formatTxResult(cdc, resTxs[i], resBlocks[resTxs[i].Height])
+		out[i], err = formatTxResult(txConfig, resTxs[i], resBlocks[resTxs[i].Height])
 		if err != nil {
 			return nil, err
 		}
@@ -132,19 +130,19 @@ func getBlocksForTxResults(clientCtx client.Context, resTxs []*ctypes.ResultTx)
 	return resBlocks, nil
 }
 
-func formatTxResult(cdc *codec.LegacyAmino, resTx *ctypes.ResultTx, resBlock *ctypes.ResultBlock) (*sdk.TxResponse, error) {
-	tx, err := parseTx(cdc, resTx.Tx)
+func formatTxResult(txConfig client.TxConfig, resTx *ctypes.ResultTx, resBlock *ctypes.ResultBlock) (*sdk.TxResponse, error) {
+	tx, err := parseTx(txConfig, resTx.Tx)
 	if err != nil {
 		return nil, err
 	}
 
 	return sdk.NewResponseResultTx(resTx, tx, resBlock.Block.Time.Format(time.RFC3339)), nil
 }
 
-func parseTx(cdc *codec.LegacyAmino, txBytes []byte) (sdk.Tx, error) {
-	var tx types.StdTx
+func parseTx(txConfig client.TxConfig, txBytes []byte) (sdk.Tx, error) {
+	var tx sdk.Tx
 
-	err := cdc.UnmarshalBinaryBare(txBytes, &tx)
+	tx, err := txConfig.TxDecoder()(txBytes)
 	if err != nil {
 		return nil, err
 	}

x/gov/client/utils/query_test.go

@@ -1,6 +1,8 @@
-package utils
+package utils_test
 
 import (
+	"github.com/cosmos/cosmos-sdk/simapp"
+	"github.com/cosmos/cosmos-sdk/x/gov/client/utils"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -59,7 +61,7 @@ func TestGetPaginatedVotes(t *testing.T) {
 	type testCase struct {
 		description string
 		page, limit int
-		txs         []authtypes.StdTx
+		msgs        [][]sdk.Msg
 		votes       []types.Vote
 	}
 	acc1 := make(sdk.AccAddress, 20)
@@ -79,22 +81,21 @@ func TestGetPaginatedVotes(t *testing.T) {
 			description: "1MsgPerTxAll",
 			page:        1,
 			limit:       2,
-			txs: []authtypes.StdTx{
-				{Msgs: acc1Msgs[:1]},
-				{Msgs: acc2Msgs[:1]},
+			msgs: [][]sdk.Msg{
+				acc1Msgs[:1],
+				acc2Msgs[:1],
 			},
 			votes: []types.Vote{
 				types.NewVote(0, acc1, types.OptionYes),
 				types.NewVote(0, acc2, types.OptionYes)},
 		},
-
 		{
 			description: "2MsgPerTx1Chunk",
 			page:        1,
 			limit:       2,
-			txs: []authtypes.StdTx{
-				{Msgs: acc1Msgs},
-				{Msgs: acc2Msgs},
+			msgs: [][]sdk.Msg{
+				acc1Msgs,
+				acc2Msgs,
 			},
 			votes: []types.Vote{
 				types.NewVote(0, acc1, types.OptionYes),
@@ -104,9 +105,9 @@ func TestGetPaginatedVotes(t *testing.T) {
 			description: "2MsgPerTx2Chunk",
 			page:        2,
 			limit:       2,
-			txs: []authtypes.StdTx{
-				{Msgs: acc1Msgs},
-				{Msgs: acc2Msgs},
+			msgs: [][]sdk.Msg{
+				acc1Msgs,
+				acc2Msgs,
 			},
 			votes: []types.Vote{
 				types.NewVote(0, acc2, types.OptionYes),
@@ -116,49 +117,54 @@ func TestGetPaginatedVotes(t *testing.T) {
 			description: "IncompleteSearchTx",
 			page:        1,
 			limit:       2,
-			txs: []authtypes.StdTx{
-				{Msgs: acc1Msgs[:1]},
+			msgs: [][]sdk.Msg{
+				acc1Msgs[:1],
 			},
 			votes: []types.Vote{types.NewVote(0, acc1, types.OptionYes)},
 		},
 		{
 			description: "InvalidPage",
 			page:        -1,
-			txs: []authtypes.StdTx{
-				{Msgs: acc1Msgs[:1]},
+			msgs: [][]sdk.Msg{
+				acc1Msgs[:1],
 			},
 		},
 		{
 			description: "OutOfBounds",
 			page:        2,
 			limit:       10,
-			txs: []authtypes.StdTx{
-				{Msgs: acc1Msgs[:1]},
+			msgs: [][]sdk.Msg{
+				acc1Msgs[:1],
 			},
 		},
 	} {
-
 		tc := tc
 
 		t.Run(tc.description, func(t *testing.T) {
 			var (
-				marshalled = make([]tmtypes.Tx, len(tc.txs))
+				marshalled = make([]tmtypes.Tx, len(tc.msgs))
 				cdc        = newTestCodec()
 			)
 
-			for i := range tc.txs {
-				tx, err := cdc.MarshalBinaryBare(&tc.txs[i])
-				require.NoError(t, err)
-				marshalled[i] = tx
-			}
-
+			encodingConfig := simapp.MakeEncodingConfig()
 			cli := TxSearchMock{txs: marshalled}
 			clientCtx := client.Context{}.
 				WithLegacyAmino(cdc).
-				WithClient(cli)
+				WithClient(cli).
+				WithTxConfig(encodingConfig.TxConfig)
+
+			for i := range tc.msgs {
+				txBuilder := clientCtx.TxConfig.NewTxBuilder()
+				err := txBuilder.SetMsgs(tc.msgs[i]...)
+				require.NoError(t, err)
+
+				tx, err := clientCtx.TxConfig.TxEncoder()(txBuilder.GetTx())
+				require.NoError(t, err)
+				marshalled[i] = tx
+			}
 
 			params := types.NewQueryProposalVotesParams(0, tc.page, tc.limit)
-			votesData, err := QueryVotesByTxQuery(clientCtx, params)
+			votesData, err := utils.QueryVotesByTxQuery(clientCtx, params)
 			require.NoError(t, err)
 			votes := []types.Vote{}
 			require.NoError(t, clientCtx.LegacyAmino.UnmarshalJSON(votesData, &votes))

x/ibc/02-client/client/cli/query.go

@@ -211,7 +211,7 @@ func GetCmdQueryHeader() *cobra.Command {
 			}
 
 			clientCtx = clientCtx.WithHeight(height)
-			return clientCtx.PrintOutputLegacy(header)
+			return clientCtx.PrintOutput(&header)
 		},
 	}
 

x/ibc/04-channel/client/cli/query.go

@@ -161,7 +161,7 @@ func GetCmdQueryChannelClientState() *cobra.Command {
 				return err
 			}
 
-			return clientCtx.PrintOutputLegacy(res.IdentifiedClientState)
+			return clientCtx.PrintOutput(res.IdentifiedClientState)
 		},
 	}