Update x/{mint,slashing,evidence} cli to use gRPC query client

client/flags/flags.go

@@ -126,7 +126,7 @@ func AddTxFlagsToCmd(cmd *cobra.Command) {
 	viper.BindPFlag(FlagKeyringBackend, cmd.Flags().Lookup(FlagKeyringBackend))
 }
 
-// AddPaginationFlagsToCmd adds common paginations flags to command
+// AddPaginationFlagsToCmd adds common pagination flags to cmd
 func AddPaginationFlagsToCmd(cmd *cobra.Command, query string) {
 	cmd.Flags().String(FlagPageKey, "", fmt.Sprintf("pagination page-key of %s to query for", query))
 	cmd.Flags().Uint64(FlagOffset, 0, fmt.Sprintf("pagination offset of %s to query for", query))

x/evidence/client/cli/query.go

@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"context"
 	"encoding/hex"
 	"fmt"
 	"strings"
@@ -9,15 +10,15 @@ import (
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
-	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/types/query"
 	"github.com/cosmos/cosmos-sdk/version"
 	"github.com/cosmos/cosmos-sdk/x/evidence/exported"
 	"github.com/cosmos/cosmos-sdk/x/evidence/types"
 )
 
 // GetQueryCmd returns the CLI command with all evidence module query commands
 // mounted.
-func GetQueryCmd(queryRoute string, cdc *codec.Codec) *cobra.Command {
+func GetQueryCmd() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   types.ModuleName,
 		Short: "Query for evidence by hash or for all (paginated) submitted evidence",
@@ -34,81 +35,83 @@ $ %s query %s --page=2 --limit=50
 		Args:                       cobra.MaximumNArgs(1),
 		DisableFlagParsing:         true,
 		SuggestionsMinimumDistance: 2,
-		RunE:                       QueryEvidenceCmd(cdc),
+		RunE:                       QueryEvidenceCmd(),
 	}
 
-	cmd.Flags().Int(flags.FlagPage, 1, "pagination page of evidence to to query for")
-	cmd.Flags().Int(flags.FlagLimit, 100, "pagination limit of evidence to query for")
 	flags.AddQueryFlagsToCmd(cmd)
+	flags.AddPaginationFlagsToCmd(cmd, "evidence")
 
 	return cmd
 }
 
 // QueryEvidenceCmd returns the command handler for evidence querying. Evidence
 // can be queried for by hash or paginated evidence can be returned.
-func QueryEvidenceCmd(cdc *codec.Codec) func(*cobra.Command, []string) error {
+func QueryEvidenceCmd() func(*cobra.Command, []string) error {
 	return func(cmd *cobra.Command, args []string) error {
 		if err := client.ValidateCmd(cmd, args); err != nil {
 			return err
 		}
 
-		clientCtx := client.NewContext().WithCodec(cdc).WithJSONMarshaler(cdc)
+		clientCtx := client.GetClientContextFromCmd(cmd)
+		clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags())
+		if err != nil {
+			return err
+		}
 
 		if hash := args[0]; hash != "" {
-			return queryEvidence(cdc, clientCtx, hash)
+			return queryEvidence(clientCtx, hash)
 		}
 
-		page, _ := cmd.Flags().GetInt(flags.FlagPage)
-		limit, _ := cmd.Flags().GetInt(flags.FlagLimit)
-
-		return queryAllEvidence(clientCtx, page, limit)
+		return queryAllEvidence(clientCtx, client.ReadPageRequest(cmd.Flags()))
 	}
 }
 
-func queryEvidence(cdc *codec.Codec, clientCtx client.Context, hash string) error {
+func queryEvidence(clientCtx client.Context, hash string) error {
 	decodedHash, err := hex.DecodeString(hash)
 	if err != nil {
 		return fmt.Errorf("invalid evidence hash: %w", err)
 	}
 
-	params := types.NewQueryEvidenceRequest(decodedHash)
-	bz, err := cdc.MarshalJSON(params)
-	if err != nil {
-		return fmt.Errorf("failed to marshal query params: %w", err)
-	}
+	queryClient := types.NewQueryClient(clientCtx)
+
+	params := &types.QueryEvidenceRequest{EvidenceHash: decodedHash}
+	res, err := queryClient.Evidence(context.Background(), params)
 
-	route := fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryEvidence)
-	res, _, err := clientCtx.QueryWithData(route, bz)
 	if err != nil {
 		return err
 	}
 
 	var evidence exported.Evidence
-	err = cdc.UnmarshalJSON(res, &evidence)
+	err = clientCtx.InterfaceRegistry.UnpackAny(res.Evidence, &evidence)
 	if err != nil {
-		return fmt.Errorf("failed to unmarshal evidence: %w", err)
+		return err
 	}
 
 	return clientCtx.PrintOutput(evidence)
 }
 
-func queryAllEvidence(clientCtx client.Context, page, limit int) error {
-	params := types.NewQueryAllEvidenceParams(page, limit)
-	bz, err := clientCtx.JSONMarshaler.MarshalJSON(params)
-	if err != nil {
-		return fmt.Errorf("failed to marshal query params: %w", err)
+func queryAllEvidence(clientCtx client.Context, pageReq *query.PageRequest) error {
+	queryClient := types.NewQueryClient(clientCtx)
+
+	params := &types.QueryAllEvidenceRequest{
+		Req: pageReq,
 	}
 
-	route := fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryAllEvidence)
-	res, _, err := clientCtx.QueryWithData(route, bz)
+	res, err := queryClient.AllEvidence(context.Background(), params)
+
 	if err != nil {
 		return err
 	}
 
-	var evidence []exported.Evidence
-	err = clientCtx.JSONMarshaler.UnmarshalJSON(res, &evidence)
-	if err != nil {
-		return fmt.Errorf("failed to unmarshal evidence: %w", err)
+	evidence := make([]exported.Evidence, 0, len(res.Evidence))
+	for _, eviAny := range res.Evidence {
+		var evi exported.Evidence
+		err = clientCtx.InterfaceRegistry.UnpackAny(eviAny, &evi)
+		if err != nil {
+			return err
+		}
+
+		evidence = append(evidence, evi)
 	}
 
 	return clientCtx.PrintOutput(evidence)

x/evidence/module.go

@@ -96,9 +96,9 @@ func (a AppModuleBasic) GetTxCmd(clientCtx client.Context) *cobra.Command {
 	return cli.GetTxCmd(clientCtx, evidenceCLIHandlers)
 }
 
-// GetTxCmd returns the evidence module's root query command.
-func (AppModuleBasic) GetQueryCmd(clientCtx client.Context) *cobra.Command {
-	return cli.GetQueryCmd(types.StoreKey, clientCtx.Codec)
+// GetQueryCmd returns the evidence module's root query command.
+func (AppModuleBasic) GetQueryCmd(_ client.Context) *cobra.Command {
+	return cli.GetQueryCmd()
 }
 
 func (AppModuleBasic) RegisterInterfaceTypes(registry codectypes.InterfaceRegistry) {

x/mint/client/cli/query.go

@@ -1,19 +1,17 @@
 package cli
 
 import (
-	"fmt"
+	"context"
 
 	"github.com/spf13/cobra"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
-	"github.com/cosmos/cosmos-sdk/codec"
-	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/x/mint/types"
 )
 
 // GetQueryCmd returns the cli query commands for the minting module.
-func GetQueryCmd(cdc *codec.Codec) *cobra.Command {
+func GetQueryCmd() *cobra.Command {
 	mintingQueryCmd := &cobra.Command{
 		Use:                        types.ModuleName,
 		Short:                      "Querying commands for the minting module",
@@ -23,36 +21,38 @@ func GetQueryCmd(cdc *codec.Codec) *cobra.Command {
 	}
 
 	mintingQueryCmd.AddCommand(
-		GetCmdQueryParams(cdc),
-		GetCmdQueryInflation(cdc),
-		GetCmdQueryAnnualProvisions(cdc),
+		GetCmdQueryParams(),
+		GetCmdQueryInflation(),
+		GetCmdQueryAnnualProvisions(),
 	)
 
 	return mintingQueryCmd
 }
 
 // GetCmdQueryParams implements a command to return the current minting
 // parameters.
-func GetCmdQueryParams(cdc *codec.Codec) *cobra.Command {
+func GetCmdQueryParams() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "params",
 		Short: "Query the current minting parameters",
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			clientCtx := client.NewContext().WithCodec(cdc).WithJSONMarshaler(cdc)
-
-			route := fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryParameters)
-			res, _, err := clientCtx.QueryWithData(route, nil)
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags())
 			if err != nil {
 				return err
 			}
 
-			var params types.Params
-			if err := cdc.UnmarshalJSON(res, &params); err != nil {
+			queryClient := types.NewQueryClient(clientCtx)
+
+			params := &types.QueryParamsRequest{}
+			res, err := queryClient.Params(context.Background(), params)
+
+			if err != nil {
 				return err
 			}
 
-			return clientCtx.PrintOutput(params)
+			return clientCtx.PrintOutput(res.Params)
 		},
 	}
 
@@ -63,26 +63,28 @@ func GetCmdQueryParams(cdc *codec.Codec) *cobra.Command {
 
 // GetCmdQueryInflation implements a command to return the current minting
 // inflation value.
-func GetCmdQueryInflation(cdc *codec.Codec) *cobra.Command {
+func GetCmdQueryInflation() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "inflation",
 		Short: "Query the current minting inflation value",
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			clientCtx := client.NewContext().WithCodec(cdc).WithJSONMarshaler(cdc)
-
-			route := fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryInflation)
-			res, _, err := clientCtx.QueryWithData(route, nil)
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags())
 			if err != nil {
 				return err
 			}
 
-			var inflation sdk.Dec
-			if err := cdc.UnmarshalJSON(res, &inflation); err != nil {
+			queryClient := types.NewQueryClient(clientCtx)
+
+			params := &types.QueryInflationRequest{}
+			res, err := queryClient.Inflation(context.Background(), params)
+
+			if err != nil {
 				return err
 			}
 
-			return clientCtx.PrintOutput(inflation)
+			return clientCtx.PrintOutput(res.Inflation)
 		},
 	}
 
@@ -93,26 +95,28 @@ func GetCmdQueryInflation(cdc *codec.Codec) *cobra.Command {
 
 // GetCmdQueryAnnualProvisions implements a command to return the current minting
 // annual provisions value.
-func GetCmdQueryAnnualProvisions(cdc *codec.Codec) *cobra.Command {
+func GetCmdQueryAnnualProvisions() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "annual-provisions",
 		Short: "Query the current minting annual provisions value",
 		Args:  cobra.NoArgs,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			clientCtx := client.NewContext().WithCodec(cdc).WithJSONMarshaler(cdc)
-
-			route := fmt.Sprintf("custom/%s/%s", types.QuerierRoute, types.QueryAnnualProvisions)
-			res, _, err := clientCtx.QueryWithData(route, nil)
+			clientCtx := client.GetClientContextFromCmd(cmd)
+			clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags())
 			if err != nil {
 				return err
 			}
 
-			var inflation sdk.Dec
-			if err := cdc.UnmarshalJSON(res, &inflation); err != nil {
+			queryClient := types.NewQueryClient(clientCtx)
+
+			params := &types.QueryAnnualProvisionsRequest{}
+			res, err := queryClient.AnnualProvisions(context.Background(), params)
+
+			if err != nil {
 				return err
 			}
 
-			return clientCtx.PrintOutput(inflation)
+			return clientCtx.PrintOutput(res.AnnualProvisions)
 		},
 	}
 

x/mint/module.go

@@ -70,7 +70,7 @@ func (AppModuleBasic) GetTxCmd(_ client.Context) *cobra.Command { return nil }
 
 // GetQueryCmd returns the root query command for the mint module.
 func (AppModuleBasic) GetQueryCmd(clientCtx client.Context) *cobra.Command {
-	return cli.GetQueryCmd(clientCtx.Codec)
+	return cli.GetQueryCmd()
 }
 
 //____________________________________________________________________________