363 lines
10 KiB
Go
363 lines
10 KiB
Go
package cli
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/cosmos/cosmos-sdk/client"
|
|
"github.com/cosmos/cosmos-sdk/client/flags"
|
|
"github.com/cosmos/cosmos-sdk/client/tx"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/version"
|
|
govutils "github.com/cosmos/cosmos-sdk/x/gov/client/utils"
|
|
"github.com/cosmos/cosmos-sdk/x/gov/types"
|
|
v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
|
|
"github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
|
|
)
|
|
|
|
// Proposal flags
|
|
const (
|
|
// Deprecated: only used for v1beta1 legacy proposals.
|
|
FlagTitle = "title"
|
|
// Deprecated: only used for v1beta1 legacy proposals.
|
|
FlagDescription = "description"
|
|
// Deprecated: only used for v1beta1 legacy proposals.
|
|
FlagProposalType = "type"
|
|
FlagDeposit = "deposit"
|
|
flagVoter = "voter"
|
|
flagDepositor = "depositor"
|
|
flagStatus = "status"
|
|
flagMetadata = "metadata"
|
|
// Deprecated: only used for v1beta1 legacy proposals.
|
|
FlagProposal = "proposal"
|
|
)
|
|
|
|
// ProposalFlags defines the core required fields of a legacy proposal. It is used to
|
|
// verify that these values are not provided in conjunction with a JSON proposal
|
|
// file.
|
|
var ProposalFlags = []string{
|
|
FlagTitle,
|
|
FlagDescription,
|
|
FlagProposalType,
|
|
FlagDeposit,
|
|
}
|
|
|
|
// NewTxCmd returns the transaction commands for this module
|
|
// governance ModuleClient is slightly different from other ModuleClients in that
|
|
// it contains a slice of legacy "proposal" child commands. These commands are respective
|
|
// to the proposal type handlers that are implemented in other modules but are mounted
|
|
// under the governance CLI (eg. parameter change proposals).
|
|
func NewTxCmd(legacyPropCmds []*cobra.Command) *cobra.Command {
|
|
govTxCmd := &cobra.Command{
|
|
Use: types.ModuleName,
|
|
Short: "Governance transactions subcommands",
|
|
DisableFlagParsing: true,
|
|
SuggestionsMinimumDistance: 2,
|
|
RunE: client.ValidateCmd,
|
|
}
|
|
|
|
cmdSubmitLegacyProp := NewCmdSubmitLegacyProposal()
|
|
for _, propCmd := range legacyPropCmds {
|
|
flags.AddTxFlagsToCmd(propCmd)
|
|
cmdSubmitLegacyProp.AddCommand(propCmd)
|
|
}
|
|
|
|
govTxCmd.AddCommand(
|
|
NewCmdDeposit(),
|
|
NewCmdVote(),
|
|
NewCmdWeightedVote(),
|
|
NewCmdSubmitProposal(),
|
|
NewCmdDraftProposal(),
|
|
|
|
// Deprecated
|
|
cmdSubmitLegacyProp,
|
|
)
|
|
|
|
return govTxCmd
|
|
}
|
|
|
|
// NewCmdSubmitProposal implements submitting a proposal transaction command.
|
|
func NewCmdSubmitProposal() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "submit-proposal [path/to/proposal.json]",
|
|
Short: "Submit a proposal along with some messages, metadata and deposit",
|
|
Args: cobra.ExactArgs(1),
|
|
Long: strings.TrimSpace(
|
|
fmt.Sprintf(`Submit a proposal along with some messages, metadata and deposit.
|
|
They should be defined in a JSON file.
|
|
|
|
Example:
|
|
$ %s tx gov submit-proposal path/to/proposal.json
|
|
|
|
Where proposal.json contains:
|
|
|
|
{
|
|
// array of proto-JSON-encoded sdk.Msgs
|
|
"messages": [
|
|
{
|
|
"@type": "/cosmos.bank.v1beta1.MsgSend",
|
|
"from_address": "cosmos1...",
|
|
"to_address": "cosmos1...",
|
|
"amount":[{"denom": "stake","amount": "10"}]
|
|
}
|
|
],
|
|
"metadata: "4pIMOgIGx1vZGU=", // base64-encoded metadata
|
|
"deposit": "10stake"
|
|
}
|
|
`,
|
|
version.AppName,
|
|
),
|
|
),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
clientCtx, err := client.GetClientTxContext(cmd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
msgs, metadata, deposit, err := parseSubmitProposal(clientCtx.Codec, args[0])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
msg, err := v1.NewMsgSubmitProposal(msgs, deposit, clientCtx.GetFromAddress().String(), metadata)
|
|
if err != nil {
|
|
return fmt.Errorf("invalid message: %w", err)
|
|
}
|
|
|
|
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
|
|
},
|
|
}
|
|
|
|
flags.AddTxFlagsToCmd(cmd)
|
|
|
|
return cmd
|
|
}
|
|
|
|
// NewCmdSubmitLegacyProposal implements submitting a proposal transaction command.
|
|
// Deprecated: please use NewCmdSubmitProposal instead.
|
|
func NewCmdSubmitLegacyProposal() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "submit-legacy-proposal",
|
|
Short: "Submit a legacy proposal along with an initial deposit",
|
|
Long: strings.TrimSpace(
|
|
fmt.Sprintf(`Submit a legacy proposal along with an initial deposit.
|
|
Proposal title, description, type and deposit can be given directly or through a proposal JSON file.
|
|
|
|
Example:
|
|
$ %s tx gov submit-legacy-proposal --proposal="path/to/proposal.json" --from mykey
|
|
|
|
Where proposal.json contains:
|
|
|
|
{
|
|
"title": "Test Proposal",
|
|
"description": "My awesome proposal",
|
|
"type": "Text",
|
|
"deposit": "10test"
|
|
}
|
|
|
|
Which is equivalent to:
|
|
|
|
$ %s tx gov submit-legacy-proposal --title="Test Proposal" --description="My awesome proposal" --type="Text" --deposit="10test" --from mykey
|
|
`,
|
|
version.AppName, version.AppName,
|
|
),
|
|
),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
clientCtx, err := client.GetClientTxContext(cmd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
proposal, err := parseSubmitLegacyProposalFlags(cmd.Flags())
|
|
if err != nil {
|
|
return fmt.Errorf("failed to parse proposal: %w", err)
|
|
}
|
|
|
|
amount, err := sdk.ParseCoinsNormalized(proposal.Deposit)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
content, ok := v1beta1.ContentFromProposalType(proposal.Title, proposal.Description, proposal.Type)
|
|
if !ok {
|
|
return fmt.Errorf("failed to create proposal content: unknown proposal type %s", proposal.Type)
|
|
}
|
|
|
|
msg, err := v1beta1.NewMsgSubmitProposal(content, amount, clientCtx.GetFromAddress())
|
|
if err != nil {
|
|
return fmt.Errorf("invalid message: %w", err)
|
|
}
|
|
|
|
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
|
|
},
|
|
}
|
|
|
|
cmd.Flags().String(FlagTitle, "", "The proposal title")
|
|
cmd.Flags().String(FlagDescription, "", "The proposal description")
|
|
cmd.Flags().String(FlagProposalType, "", "The proposal Type")
|
|
cmd.Flags().String(FlagDeposit, "", "The proposal deposit")
|
|
cmd.Flags().String(FlagProposal, "", "Proposal file path (if this path is given, other proposal flags are ignored)")
|
|
flags.AddTxFlagsToCmd(cmd)
|
|
|
|
return cmd
|
|
}
|
|
|
|
// NewCmdDeposit implements depositing tokens for an active proposal.
|
|
func NewCmdDeposit() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "deposit [proposal-id] [deposit]",
|
|
Args: cobra.ExactArgs(2),
|
|
Short: "Deposit tokens for an active proposal",
|
|
Long: strings.TrimSpace(
|
|
fmt.Sprintf(`Submit a deposit for an active proposal. You can
|
|
find the proposal-id by running "%s query gov proposals".
|
|
|
|
Example:
|
|
$ %s tx gov deposit 1 10stake --from mykey
|
|
`,
|
|
version.AppName, version.AppName,
|
|
),
|
|
),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
clientCtx, err := client.GetClientTxContext(cmd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// validate that the proposal id is a uint
|
|
proposalID, err := strconv.ParseUint(args[0], 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("proposal-id %s not a valid uint, please input a valid proposal-id", args[0])
|
|
}
|
|
|
|
// Get depositor address
|
|
from := clientCtx.GetFromAddress()
|
|
|
|
// Get amount of coins
|
|
amount, err := sdk.ParseCoinsNormalized(args[1])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
msg := v1.NewMsgDeposit(from, proposalID, amount)
|
|
|
|
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
|
|
},
|
|
}
|
|
|
|
flags.AddTxFlagsToCmd(cmd)
|
|
|
|
return cmd
|
|
}
|
|
|
|
// NewCmdVote implements creating a new vote command.
|
|
func NewCmdVote() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "vote [proposal-id] [option]",
|
|
Args: cobra.ExactArgs(2),
|
|
Short: "Vote for an active proposal, options: yes/no/no_with_veto/abstain",
|
|
Long: strings.TrimSpace(
|
|
fmt.Sprintf(`Submit a vote for an active proposal. You can
|
|
find the proposal-id by running "%s query gov proposals".
|
|
|
|
Example:
|
|
$ %s tx gov vote 1 yes --from mykey
|
|
`,
|
|
version.AppName, version.AppName,
|
|
),
|
|
),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
clientCtx, err := client.GetClientTxContext(cmd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Get voting address
|
|
from := clientCtx.GetFromAddress()
|
|
|
|
// validate that the proposal id is a uint
|
|
proposalID, err := strconv.ParseUint(args[0], 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("proposal-id %s not a valid int, please input a valid proposal-id", args[0])
|
|
}
|
|
|
|
// Find out which vote option user chose
|
|
byteVoteOption, err := v1.VoteOptionFromString(govutils.NormalizeVoteOption(args[1]))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
metadata, err := cmd.Flags().GetString(flagMetadata)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Build vote message and run basic validation
|
|
msg := v1.NewMsgVote(from, proposalID, byteVoteOption, metadata)
|
|
|
|
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
|
|
},
|
|
}
|
|
|
|
cmd.Flags().String(flagMetadata, "", "Specify metadata of the vote")
|
|
flags.AddTxFlagsToCmd(cmd)
|
|
|
|
return cmd
|
|
}
|
|
|
|
// NewCmdWeightedVote implements creating a new weighted vote command.
|
|
func NewCmdWeightedVote() *cobra.Command {
|
|
cmd := &cobra.Command{
|
|
Use: "weighted-vote [proposal-id] [weighted-options]",
|
|
Args: cobra.ExactArgs(2),
|
|
Short: "Vote for an active proposal, options: yes/no/no_with_veto/abstain",
|
|
Long: strings.TrimSpace(
|
|
fmt.Sprintf(`Submit a vote for an active proposal. You can
|
|
find the proposal-id by running "%s query gov proposals".
|
|
|
|
Example:
|
|
$ %s tx gov weighted-vote 1 yes=0.6,no=0.3,abstain=0.05,no_with_veto=0.05 --from mykey
|
|
`,
|
|
version.AppName, version.AppName,
|
|
),
|
|
),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
clientCtx, err := client.GetClientTxContext(cmd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Get voter address
|
|
from := clientCtx.GetFromAddress()
|
|
|
|
// validate that the proposal id is a uint
|
|
proposalID, err := strconv.ParseUint(args[0], 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("proposal-id %s not a valid int, please input a valid proposal-id", args[0])
|
|
}
|
|
|
|
// Figure out which vote options user chose
|
|
options, err := v1.WeightedVoteOptionsFromString(govutils.NormalizeWeightedVoteOptions(args[1]))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
metadata, err := cmd.Flags().GetString(flagMetadata)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Build vote message and run basic validation
|
|
msg := v1.NewMsgVoteWeighted(from, proposalID, options, metadata)
|
|
return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
|
|
},
|
|
}
|
|
|
|
cmd.Flags().String(flagMetadata, "", "Specify metadata of the weighted vote")
|
|
flags.AddTxFlagsToCmd(cmd)
|
|
|
|
return cmd
|
|
}
|