query.go

package cli

import (
	"context"
	"encoding/base64"
	"fmt"
	"strconv"
	"strings"

	"github.com/cosmos/cosmos-sdk/client"
	"github.com/cosmos/cosmos-sdk/client/flags"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/version"
	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
	"github.com/spf13/cobra"
	flag "github.com/spf13/pflag"

	"github.com/furyanrasta/furya/x/poe/types"
)

func GetQueryCmd() *cobra.Command {
	queryCmd := &cobra.Command{
		Use:                        types.ModuleName,
		Short:                      "Querying commands for the PoE module",
		DisableFlagParsing:         true,
		SuggestionsMinimumDistance: 2,
		RunE:                       client.ValidateCmd,
	}
	queryCmd.AddCommand(
		GetCmdShowPoEContract(),
		GetCmdQueryValidators(),
		GetCmdQueryValidator(),
		GetCmdQueryValidatorDelegation(),
		GetCmdQueryValidatorUnbondingDelegations(),
		GetCmdQueryUnbondingPeriod(),
		GetCmdQueryHistoricalInfo(),
		GetCmdQueryValidatorReward(),
	)
	return queryCmd
}

func GetCmdShowPoEContract() *cobra.Command {
	cmd := &cobra.Command{
		Use:     "contract-address <contract_type>",
		Short:   "Show contract address for given contract type",
		Long:    fmt.Sprintf("Show contract address for PoE type [%s]", allPoEContractTypeNames()),
		Aliases: []string{"ca"},
		Args:    cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}

			cbt := types.PoEContractTypeFrom(args[0])
			if cbt == types.PoEContractTypeUndefined {
				return fmt.Errorf("unknown contract type: %q", args[0])
			}

			queryClient := types.NewQueryClient(clientCtx)
			res, err := queryClient.ContractAddress(
				cmd.Context(),
				&types.QueryContractAddressRequest{
					ContractType: cbt,
				},
			)
			if err != nil {
				return err
			}

			if printAddr, err := cmd.Flags().GetBool(flagAddress); err == nil && printAddr {
				return clientCtx.PrintString(res.Address)
			}
			return clientCtx.PrintProto(res)
		},
	}
	flags.AddQueryFlagsToCmd(cmd)
	cmd.Flags().BoolP(flagAddress, "a", false, "print the bech32 address only")
	return cmd
}

func GetCmdQueryUnbondingPeriod() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "unbonding-period",
		Short: "Query the global unbonding period",
		Args:  cobra.ExactArgs(0),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}

			queryClient := types.NewQueryClient(clientCtx)
			res, err := queryClient.UnbondingPeriod(
				cmd.Context(),
				&types.QueryUnbondingPeriodRequest{},
			)
			if err != nil {
				return err
			}
			return clientCtx.PrintProto(res)
		},
	}
	flags.AddQueryFlagsToCmd(cmd)
	return cmd
}

// GetCmdQueryValidators implements the query all validators command.
func GetCmdQueryValidators() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "validators",
		Short: "Query for all validators",
		Args:  cobra.NoArgs,
		Long: strings.TrimSpace(
			fmt.Sprintf(`Query details about all validators on a network.

Example:
$ %s query poe validators
`,
				version.AppName,
			),
		),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}
			queryClient := types.NewQueryClient(clientCtx)
			pageReq, err := client.ReadPageRequest(withPageKeyDecoded(cmd.Flags()))
			if err != nil {
				return err
			}
			result, err := queryClient.Validators(cmd.Context(), &stakingtypes.QueryValidatorsRequest{
				// Leaving status empty on purpose to query all validators.
				Pagination: pageReq,
			})
			if err != nil {
				return err
			}

			return clientCtx.PrintProto(result)
		},
	}

	flags.AddQueryFlagsToCmd(cmd)
	AddPaginationFlagsToCmd(cmd, "validators")
	return cmd
}

// GetCmdQueryValidator implements the validator query command.
func GetCmdQueryValidator() *cobra.Command {
	bech32PrefixValAddr := sdk.GetConfig().GetBech32ValidatorAddrPrefix()

	cmd := &cobra.Command{
		Use:   "validator [operator-addr]",
		Short: "Query a validator",
		Long: strings.TrimSpace(
			fmt.Sprintf(`Query details about an individual validator.

Example:
$ %s query poe validator %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
`,
				version.AppName, bech32PrefixValAddr,
			),
		),
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}
			queryClient := types.NewQueryClient(clientCtx)

			addr, err := sdk.AccAddressFromBech32(args[0])
			if err != nil {
				return err
			}

			params := &stakingtypes.QueryValidatorRequest{ValidatorAddr: addr.String()}
			res, err := queryClient.Validator(cmd.Context(), params)
			if err != nil {
				return err
			}

			return clientCtx.PrintProto(&res.Validator)
		},
	}
	flags.AddQueryFlagsToCmd(cmd)
	return cmd
}

// returns comma separated list of all poe contract type names
func allPoEContractTypeNames() string {
	var names []string
	types.IteratePoEContractTypes(func(tp types.PoEContractType) bool {
		names = append(names, tp.String())
		return false
	})
	return strings.Join(names, ", ")
}

// GetCmdQueryHistoricalInfo implements the historical info query command
func GetCmdQueryHistoricalInfo() *cobra.Command {
	cmd := &cobra.Command{
		Use:   "historical-info [height]",
		Args:  cobra.ExactArgs(1),
		Short: "Query historical info at given height",
		Long: strings.TrimSpace(
			fmt.Sprintf(`Query historical info at given height.

Example:
$ %s query poe historical-info 5
`,
				version.AppName,
			),
		),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}
			queryClient := types.NewQueryClient(clientCtx)

			height, err := strconv.ParseInt(args[0], 10, 64)
			if err != nil || height < 0 {
				return fmt.Errorf("height argument provided must be a non-negative-integer: %v", err)
			}

			params := &stakingtypes.QueryHistoricalInfoRequest{Height: height}
			res, err := queryClient.HistoricalInfo(context.Background(), params)
			if err != nil {
				return err
			}

			return clientCtx.PrintProto(res.Hist)
		},
	}

	flags.AddQueryFlagsToCmd(cmd)

	return cmd
}

// GetCmdQueryValidatorDelegation implements the command to query the
// self delegation of a specific validator.
func GetCmdQueryValidatorDelegation() *cobra.Command {
	bech32PrefixValAddr := sdk.GetConfig().GetBech32ValidatorAddrPrefix()

	cmd := &cobra.Command{
		Use:   "self-delegation [validator-addr]",
		Short: "Query the delegation made by one validator",
		Long: strings.TrimSpace(
			fmt.Sprintf(`Query delegations on an individual validator.

Example:
$ %s query poe self-delegation %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
`,
				version.AppName, bech32PrefixValAddr,
			),
		),
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}
			queryClient := types.NewQueryClient(clientCtx)

			valAddr, err := sdk.ValAddressFromBech32(args[0])
			if err != nil {
				return err
			}

			params := &types.QueryValidatorDelegationRequest{
				ValidatorAddr: valAddr.String(),
			}

			res, err := queryClient.ValidatorDelegation(context.Background(), params)
			if err != nil {
				return err
			}

			return clientCtx.PrintProto(res)
		},
	}

	flags.AddQueryFlagsToCmd(cmd)
	return cmd
}

// GetCmdQueryValidatorUnbondingDelegations implements the query all unbonding delegatations from a validator command.
func GetCmdQueryValidatorUnbondingDelegations() *cobra.Command {
	bech32PrefixValAddr := sdk.GetConfig().GetBech32ValidatorAddrPrefix()

	cmd := &cobra.Command{
		Use:   "unbonding-delegations [validator-addr]",
		Short: "Query all unbonding delegations from a validator",
		Long: strings.TrimSpace(
			fmt.Sprintf(`Query delegations that are unbonding _from_ a validator.

Example:
$ %s query poe unbonding-delegations %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
`,
				version.AppName, bech32PrefixValAddr,
			),
		),
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}
			queryClient := types.NewQueryClient(clientCtx)

			valAddr, err := sdk.ValAddressFromBech32(args[0])
			if err != nil {
				return err
			}

			pageReq, err := client.ReadPageRequest(withPageKeyDecoded(cmd.Flags()))
			if err != nil {
				return err
			}

			params := &types.QueryValidatorUnbondingDelegationsRequest{
				ValidatorAddr: valAddr.String(),
				Pagination:    pageReq,
			}

			res, err := queryClient.ValidatorUnbondingDelegations(context.Background(), params)
			if err != nil {
				return err
			}

			return clientCtx.PrintProto(res)
		},
	}

	flags.AddQueryFlagsToCmd(cmd)
	AddPaginationFlagsToCmd(cmd, "unbonding delegations")

	return cmd
}

// GetCmdQueryValidatorReward implements the command to query the
// claimable reward of a specific validator.
func GetCmdQueryValidatorReward() *cobra.Command {
	bech32PrefixValAddr := sdk.GetConfig().GetBech32ValidatorAddrPrefix()

	cmd := &cobra.Command{
		Use:     "validator-reward [validator-addr]",
		Short:   "Query the pending reward by one validator",
		Aliases: []string{"validator-rewards", "rewards", "reward"},
		Long: strings.TrimSpace(
			fmt.Sprintf(`Query reward of an individual validator.

Example:
$ %s query poe validator-reward %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
`,
				version.AppName, bech32PrefixValAddr,
			),
		),
		Args: cobra.ExactArgs(1),
		RunE: func(cmd *cobra.Command, args []string) error {
			clientCtx, err := client.GetClientQueryContext(cmd)
			if err != nil {
				return err
			}
			queryClient := types.NewQueryClient(clientCtx)

			valAddr, err := sdk.ValAddressFromBech32(args[0])
			if err != nil {
				return err
			}

			distrRewards, err := cmd.Flags().GetBool(flagDistribution)
			if err != nil {
				return err
			}
			engRewards, err := cmd.Flags().GetBool(flagEngagement)
			if err != nil {
				return err
			}

			total := sdk.ZeroDec()
			if !(distrRewards || engRewards) {
				reward, err := queryDistributionRewards(queryClient, valAddr)
				if err != nil {
					return err
				}
				total = total.Add(reward.Amount)

				reward, err = queryEngagementRewards(queryClient, valAddr)
				if err != nil {
					return err
				}
				total = total.Add(reward.Amount)
			}

			if distrRewards {
				reward, err := queryDistributionRewards(queryClient, valAddr)
				if err != nil {
					return err
				}
				total = total.Add(reward.Amount)
			}

			if engRewards {
				reward, err := queryEngagementRewards(queryClient, valAddr)
				if err != nil {
					return err
				}
				total = total.Add(reward.Amount)
			}

			return clientCtx.PrintString(total.String())
		},
	}

	flags.AddQueryFlagsToCmd(cmd)
	cmd.Flags().BoolP(flagEngagement, "", false, "query engagement rewards")
	cmd.Flags().BoolP(flagDistribution, "", false, "query distribution rewards")
	return cmd
}

func queryDistributionRewards(queryClient types.QueryClient, valAddr sdk.ValAddress) (sdk.DecCoin, error) {
	req := &types.QueryValidatorOutstandingRewardRequest{
		ValidatorAddress: valAddr.String(),
	}
	res, err := queryClient.ValidatorOutstandingReward(context.Background(), req)
	if err != nil {
		return sdk.DecCoin{}, err
	}
	return res.Reward, nil
}

func queryEngagementRewards(queryClient types.QueryClient, valAddr sdk.ValAddress) (sdk.DecCoin, error) {
	req := &types.QueryValidatorEngagementRewardRequest{
		ValidatorAddress: valAddr.String(),
	}
	res, err := queryClient.ValidatorEngagementReward(context.Background(), req)
	if err != nil {
		return sdk.DecCoin{}, err
	}
	return res.Reward, nil
}

// AddPaginationFlagsToCmd adds common pagination flags to cmd
func AddPaginationFlagsToCmd(cmd *cobra.Command, query string) {
	// we support only a subset in the contracts yet
	cmd.Flags().String(flags.FlagPageKey, "", fmt.Sprintf("pagination page-key of %s to query for", query))
	cmd.Flags().Uint64(flags.FlagLimit, 100, fmt.Sprintf("pagination limit of %s to query for", query))
}

// sdk ReadPageRequest expects binary but we encoded to base64 in our marshaller
func withPageKeyDecoded(flagSet *flag.FlagSet) *flag.FlagSet {
	encoded, err := flagSet.GetString(flags.FlagPageKey)
	if err != nil {
		panic(err.Error())
	}
	raw, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		panic(err.Error())
	}
	err = flagSet.Set(flags.FlagPageKey, string(raw))
	if err != nil {
		panic(err.Error())
	}
	return flagSet
}