x/gov: Proto Tx CLI command

codec/std/codec.go

@@ -10,6 +10,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/x/evidence"
 	eviexported "github.com/cosmos/cosmos-sdk/x/evidence/exported"
 	"github.com/cosmos/cosmos-sdk/x/gov"
+	"github.com/cosmos/cosmos-sdk/x/gov/types"
 	"github.com/cosmos/cosmos-sdk/x/supply"
 	supplyexported "github.com/cosmos/cosmos-sdk/x/supply/exported"
 )
@@ -180,6 +181,22 @@ func (c *Codec) UnmarshalProposal(bz []byte) (gov.Proposal, error) {
 	}, nil
 }
 
+func (c *Codec) NewMsgSubmitProposal(content types.Content, initialDeposit sdk.Coins, proposer sdk.AccAddress) (types.MsgSubmitProposalI, error) {
+	stdContent := &Content{}
+	err := stdContent.SetContent(content)
+	if err != nil {
+		return nil, err
+	}
+	msg := MsgSubmitProposal{
+		MsgSubmitProposalBase: gov.MsgSubmitProposalBase{
+			InitialDeposit: initialDeposit,
+			Proposer:       proposer,
+		},
+		Content: stdContent,
+	}
+	return msg, nil
+}
+
 // ----------------------------------------------------------------------------
 // necessary types and interfaces registered. This codec is provided to all the
 // modules the application depends on.

x/gov/client/cli/tx.go

@@ -3,6 +3,7 @@ package cli
 import (
 	"bufio"
 	"fmt"
+	gov "github.com/cosmos/cosmos-sdk/x/gov/types"
 	"strconv"
 	"strings"
 
@@ -11,6 +12,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/tx"
 	"github.com/cosmos/cosmos-sdk/codec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/version"
@@ -49,6 +51,196 @@ var ProposalFlags = []string{
 	FlagDeposit,
 }
 
+// NewTxCmd returns the transaction commands for this module
+// governance ModuleClient is slightly different from other ModuleClients in that
+// it contains a slice of "proposal" child commands. These commands are respective
+// to proposal type handlers that are implemented in other modules but are mounted
+// under the governance CLI (eg. parameter change proposals).
+func NewTxCmd(cdc gov.Codec, txg tx.Generator, ar tx.AccountRetriever, pcmds []*cobra.Command) *cobra.Command {
+	govTxCmd := &cobra.Command{
+		Use:                        types.ModuleName,
+		Short:                      "Governance transactions subcommands",
+		DisableFlagParsing:         true,
+		SuggestionsMinimumDistance: 2,
+		RunE:                       client.ValidateCmd,
+	}
+
+	cmdSubmitProp := NewCmdSubmitProposal(cdc, txg, ar)
+	for _, pcmd := range pcmds {
+		cmdSubmitProp.AddCommand(flags.PostCommands(pcmd)[0])
+	}
+
+	govTxCmd.AddCommand(flags.PostCommands(
+		NewCmdDeposit(cdc, txg, ar),
+		NewCmdVote(cdc, txg, ar),
+		cmdSubmitProp,
+	)...)
+
+	return govTxCmd
+}
+
+// NewCmdSubmitProposal implements submitting a proposal transaction command.
+func NewCmdSubmitProposal(cdc gov.Codec, txg tx.Generator, ar tx.AccountRetriever) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "submit-proposal",
+		Short: "Submit a proposal along with an initial deposit",
+		Long: strings.TrimSpace(
+			fmt.Sprintf(`Submit a 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-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-proposal --title="Test Proposal" --description="My awesome proposal" --type="Text" --deposit="10test" --from mykey
+`,
+				version.ClientName, version.ClientName,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			inBuf := bufio.NewReader(cmd.InOrStdin())
+			cliCtx := context.NewCLIContextWithInputAndFrom(inBuf, args[0]).WithMarshaler(cdc)
+			txf := tx.NewFactoryFromCLI(inBuf).WithTxGenerator(txg).WithAccountRetriever(ar)
+
+			proposal, err := parseSubmitProposalFlags()
+			if err != nil {
+				return err
+			}
+
+			amount, err := sdk.ParseCoins(proposal.Deposit)
+			if err != nil {
+				return err
+			}
+
+			content := types.ContentFromProposalType(proposal.Title, proposal.Description, proposal.Type)
+
+			msg, err := cdc.NewMsgSubmitProposal(content, amount, cliCtx.GetFromAddress())
+			if err != nil {
+				return err
+			}
+			if err = msg.ValidateBasic(); err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTx(cliCtx, txf, msg)
+		},
+	}
+
+	cmd.Flags().String(FlagTitle, "", "title of proposal")
+	cmd.Flags().String(FlagDescription, "", "description of proposal")
+	cmd.Flags().String(flagProposalType, "", "proposalType of proposal, types: text/parameter_change/software_upgrade")
+	cmd.Flags().String(FlagDeposit, "", "deposit of proposal")
+	cmd.Flags().String(FlagProposal, "", "proposal file path (if this path is given, other proposal flags are ignored)")
+
+	return cmd
+}
+
+// NewCmdDeposit implements depositing tokens for an active proposal.
+func NewCmdDeposit(cdc codec.Marshaler, txg tx.Generator, ar tx.AccountRetriever) *cobra.Command {
+	return &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.ClientName, version.ClientName,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			inBuf := bufio.NewReader(cmd.InOrStdin())
+			cliCtx := context.NewCLIContextWithInputAndFrom(inBuf, args[0]).WithMarshaler(cdc)
+			txf := tx.NewFactoryFromCLI(inBuf).WithTxGenerator(txg).WithAccountRetriever(ar)
+
+			// 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 := cliCtx.GetFromAddress()
+
+			// Get amount of coins
+			amount, err := sdk.ParseCoins(args[1])
+			if err != nil {
+				return err
+			}
+
+			msg := types.NewMsgDeposit(from, proposalID, amount)
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTx(cliCtx, txf, msg)
+		},
+	}
+}
+
+// NewCmdVote implements creating a new vote command.
+func NewCmdVote(cdc codec.Marshaler, txg tx.Generator, ar tx.AccountRetriever) *cobra.Command {
+	return &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.ClientName, version.ClientName,
+			),
+		),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			inBuf := bufio.NewReader(cmd.InOrStdin())
+			cliCtx := context.NewCLIContextWithInputAndFrom(inBuf, args[0]).WithMarshaler(cdc)
+			txf := tx.NewFactoryFromCLI(inBuf).WithTxGenerator(txg).WithAccountRetriever(ar)
+
+			// Get voting address
+			from := cliCtx.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 := types.VoteOptionFromString(govutils.NormalizeVoteOption(args[1]))
+			if err != nil {
+				return err
+			}
+
+			// Build vote message and run basic validation
+			msg := types.NewMsgVote(from, proposalID, byteVoteOption)
+			err = msg.ValidateBasic()
+			if err != nil {
+				return err
+			}
+
+			return tx.GenerateOrBroadcastTx(cliCtx, txf, msg)
+		},
+	}
+}
+
 // GetTxCmd returns the transaction commands for this module
 // governance ModuleClient is slightly different from other ModuleClients in that
 // it contains a slice of "proposal" child commands. These commands are respective

x/gov/client/rest/rest.go

@@ -1,6 +1,8 @@
 package rest
 
 import (
+	"github.com/cosmos/cosmos-sdk/client/tx"
+	"github.com/cosmos/cosmos-sdk/x/gov/types"
 	"net/http"
 
 	"github.com/gorilla/mux"
@@ -28,6 +30,11 @@ type ProposalRESTHandler struct {
 	Handler  func(http.ResponseWriter, *http.Request)
 }
 
+func RegisterHandlers(cliCtx context.CLIContext, m types.Codec, txg tx.Generator, r *mux.Router, phs []ProposalRESTHandler) {
+	registerQueryRoutes(cliCtx, r)
+	registerTxHandlers(cliCtx, m, txg, r, phs)
+}
+
 // RegisterRoutes - Central function to define routes that get registered by the main application
 func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, phs []ProposalRESTHandler) {
 	registerQueryRoutes(cliCtx, r)

x/gov/client/rest/tx.go

@@ -7,13 +7,133 @@ import (
 	"github.com/gorilla/mux"
 
 	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/client/tx"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/rest"
 	authclient "github.com/cosmos/cosmos-sdk/x/auth/client"
 	gcutils "github.com/cosmos/cosmos-sdk/x/gov/client/utils"
 	"github.com/cosmos/cosmos-sdk/x/gov/types"
 )
 
+func registerTxHandlers(cliCtx context.CLIContext, m types.Codec, txg tx.Generator, r *mux.Router, phs []ProposalRESTHandler) {
+	propSubRtr := r.PathPrefix("/gov/proposals").Subrouter()
+	for _, ph := range phs {
+		propSubRtr.HandleFunc(fmt.Sprintf("/%s", ph.SubRoute), ph.Handler).Methods("POST")
+	}
+
+	cliCtx = cliCtx.WithMarshaler(m)
+	r.HandleFunc("/gov/proposals", newPostProposalHandlerFn(cliCtx, m, txg)).Methods("POST")
+	r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/deposits", RestProposalID), newDepositHandlerFn(cliCtx, txg)).Methods("POST")
+	r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/votes", RestProposalID), newVoteHandlerFn(cliCtx, txg)).Methods("POST")
+}
+
+func newPostProposalHandlerFn(cliCtx context.CLIContext, m types.Codec, txg tx.Generator) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req PostProposalReq
+		if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) {
+			return
+		}
+
+		req.BaseReq = req.BaseReq.Sanitize()
+		if !req.BaseReq.ValidateBasic(w) {
+			return
+		}
+
+		proposalType := gcutils.NormalizeProposalType(req.ProposalType)
+		content := types.ContentFromProposalType(req.Title, req.Description, proposalType)
+
+		msg, err := m.NewMsgSubmitProposal(content, req.InitialDeposit, req.Proposer)
+		if rest.CheckBadRequestError(w, err) {
+			return
+		}
+		if rest.CheckBadRequestError(w, msg.ValidateBasic()) {
+			return
+		}
+
+		tx.WriteGeneratedTxResponse(cliCtx, w, txg, req.BaseReq, msg)
+	}
+}
+
+func newDepositHandlerFn(cliCtx context.CLIContext, txg tx.Generator) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		strProposalID := vars[RestProposalID]
+
+		if len(strProposalID) == 0 {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, "proposalId required but not specified")
+			return
+		}
+
+		proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
+		if !ok {
+			return
+		}
+
+		var req DepositReq
+		if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) {
+			return
+		}
+
+		req.BaseReq = req.BaseReq.Sanitize()
+		if !req.BaseReq.ValidateBasic(w) {
+			return
+		}
+
+		// create the message
+		msg := types.NewMsgDeposit(req.Depositor, proposalID, req.Amount)
+		if rest.CheckBadRequestError(w, msg.ValidateBasic()) {
+			return
+		}
+
+		tx.WriteGeneratedTxResponse(cliCtx, w, txg, req.BaseReq, msg)
+	}
+}
+
+func newVoteHandlerFn(cliCtx context.CLIContext, txg tx.Generator) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		strProposalID := vars[RestProposalID]
+
+		if len(strProposalID) == 0 {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, "proposalId required but not specified")
+			return
+		}
+
+		proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
+		if !ok {
+			return
+		}
+
+		var req VoteReq
+		if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) {
+			return
+		}
+
+		req.BaseReq = req.BaseReq.Sanitize()
+		if !req.BaseReq.ValidateBasic(w) {
+			return
+		}
+
+		voteOption, err := types.VoteOptionFromString(gcutils.NormalizeVoteOption(req.Option))
+		if rest.CheckBadRequestError(w, err) {
+			return
+		}
+
+		// create the message
+		msg := types.NewMsgVote(req.Voter, proposalID, voteOption)
+		if rest.CheckBadRequestError(w, msg.ValidateBasic()) {
+			return
+		}
+
+		tx.WriteGeneratedTxResponse(cliCtx, w, txg, req.BaseReq, msg)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Deprecated
+//
+// TODO: Remove once client-side Protobuf migration has been completed.
+// ---------------------------------------------------------------------------
 func registerTxRoutes(cliCtx context.CLIContext, r *mux.Router, phs []ProposalRESTHandler) {
 	propSubRtr := r.PathPrefix("/gov/proposals").Subrouter()
 	for _, ph := range phs {