616 lines
18 KiB
Go
616 lines
18 KiB
Go
package rest
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
|
|
"github.com/cosmos/cosmos-sdk/client/rest"
|
|
|
|
"github.com/cosmos/cosmos-sdk/client/context"
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/cosmos/cosmos-sdk/x/gov"
|
|
gcutils "github.com/cosmos/cosmos-sdk/x/gov/client/utils"
|
|
|
|
"errors"
|
|
|
|
"github.com/gorilla/mux"
|
|
|
|
govClientUtils "github.com/cosmos/cosmos-sdk/x/gov/client/utils"
|
|
)
|
|
|
|
// REST Variable names
|
|
// nolint
|
|
const (
|
|
RestParamsType = "type"
|
|
RestProposalID = "proposal-id"
|
|
RestDepositor = "depositor"
|
|
RestVoter = "voter"
|
|
RestProposalStatus = "status"
|
|
RestNumLimit = "limit"
|
|
)
|
|
|
|
// RegisterRoutes - Central function to define routes that get registered by the main application
|
|
func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec) {
|
|
r.HandleFunc("/gov/proposals", postProposalHandlerFn(cdc, cliCtx)).Methods("POST")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/deposits", RestProposalID), depositHandlerFn(cdc, cliCtx)).Methods("POST")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/votes", RestProposalID), voteHandlerFn(cdc, cliCtx)).Methods("POST")
|
|
|
|
r.HandleFunc(
|
|
fmt.Sprintf("/gov/parameters/{%s}", RestParamsType),
|
|
queryParamsHandlerFn(cdc, cliCtx),
|
|
).Methods("GET")
|
|
|
|
r.HandleFunc("/gov/proposals", queryProposalsWithParameterFn(cdc, cliCtx)).Methods("GET")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}", RestProposalID), queryProposalHandlerFn(cdc, cliCtx)).Methods("GET")
|
|
r.HandleFunc(
|
|
fmt.Sprintf("/gov/proposals/{%s}/proposer", RestProposalID),
|
|
queryProposerHandlerFn(cdc, cliCtx),
|
|
).Methods("GET")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/deposits", RestProposalID), queryDepositsHandlerFn(cdc, cliCtx)).Methods("GET")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/deposits/{%s}", RestProposalID, RestDepositor), queryDepositHandlerFn(cdc, cliCtx)).Methods("GET")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/tally", RestProposalID), queryTallyOnProposalHandlerFn(cdc, cliCtx)).Methods("GET")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/votes", RestProposalID), queryVotesOnProposalHandlerFn(cdc, cliCtx)).Methods("GET")
|
|
r.HandleFunc(fmt.Sprintf("/gov/proposals/{%s}/votes/{%s}", RestProposalID, RestVoter), queryVoteHandlerFn(cdc, cliCtx)).Methods("GET")
|
|
}
|
|
|
|
type postProposalReq struct {
|
|
BaseReq rest.BaseReq `json:"base_req"`
|
|
Title string `json:"title"` // Title of the proposal
|
|
Description string `json:"description"` // Description of the proposal
|
|
ProposalType string `json:"proposal_type"` // Type of proposal. Initial set {PlainTextProposal, SoftwareUpgradeProposal}
|
|
Proposer sdk.AccAddress `json:"proposer"` // Address of the proposer
|
|
InitialDeposit sdk.Coins `json:"initial_deposit"` // Coins to add to the proposal's deposit
|
|
}
|
|
|
|
type depositReq struct {
|
|
BaseReq rest.BaseReq `json:"base_req"`
|
|
Depositor sdk.AccAddress `json:"depositor"` // Address of the depositor
|
|
Amount sdk.Coins `json:"amount"` // Coins to add to the proposal's deposit
|
|
}
|
|
|
|
type voteReq struct {
|
|
BaseReq rest.BaseReq `json:"base_req"`
|
|
Voter sdk.AccAddress `json:"voter"` // address of the voter
|
|
Option string `json:"option"` // option from OptionSet chosen by the voter
|
|
}
|
|
|
|
func postProposalHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
var req postProposalReq
|
|
if !rest.ReadRESTReq(w, r, cdc, &req) {
|
|
return
|
|
}
|
|
|
|
req.BaseReq = req.BaseReq.Sanitize()
|
|
if !req.BaseReq.ValidateBasic(w) {
|
|
return
|
|
}
|
|
|
|
proposalType, err := gov.ProposalTypeFromString(govClientUtils.NormalizeProposalType(req.ProposalType))
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
// create the message
|
|
msg := gov.NewMsgSubmitProposal(req.Title, req.Description, proposalType, req.Proposer, req.InitialDeposit)
|
|
if err := msg.ValidateBasic(); err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
if req.BaseReq.GenerateOnly {
|
|
rest.WriteGenerateStdTxResponse(w, cdc, cliCtx, req.BaseReq, []sdk.Msg{msg})
|
|
return
|
|
}
|
|
|
|
rest.CompleteAndBroadcastTxREST(w, r, cliCtx, req.BaseReq, []sdk.Msg{msg}, cdc)
|
|
}
|
|
}
|
|
|
|
func depositHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
|
|
if len(strProposalID) == 0 {
|
|
err := errors.New("proposalId required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var req depositReq
|
|
if !rest.ReadRESTReq(w, r, cdc, &req) {
|
|
return
|
|
}
|
|
|
|
req.BaseReq = req.BaseReq.Sanitize()
|
|
if !req.BaseReq.ValidateBasic(w) {
|
|
return
|
|
}
|
|
|
|
// create the message
|
|
msg := gov.NewMsgDeposit(req.Depositor, proposalID, req.Amount)
|
|
if err := msg.ValidateBasic(); err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
if req.BaseReq.GenerateOnly {
|
|
rest.WriteGenerateStdTxResponse(w, cdc, cliCtx, req.BaseReq, []sdk.Msg{msg})
|
|
return
|
|
}
|
|
|
|
rest.CompleteAndBroadcastTxREST(w, r, cliCtx, req.BaseReq, []sdk.Msg{msg}, cdc)
|
|
}
|
|
}
|
|
|
|
func voteHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
|
|
if len(strProposalID) == 0 {
|
|
err := errors.New("proposalId required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
var req voteReq
|
|
if !rest.ReadRESTReq(w, r, cdc, &req) {
|
|
return
|
|
}
|
|
|
|
req.BaseReq = req.BaseReq.Sanitize()
|
|
if !req.BaseReq.ValidateBasic(w) {
|
|
return
|
|
}
|
|
|
|
voteOption, err := gov.VoteOptionFromString(govClientUtils.NormalizeVoteOption(req.Option))
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
// create the message
|
|
msg := gov.NewMsgVote(req.Voter, proposalID, voteOption)
|
|
if err := msg.ValidateBasic(); err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
if req.BaseReq.GenerateOnly {
|
|
rest.WriteGenerateStdTxResponse(w, cdc, cliCtx, req.BaseReq, []sdk.Msg{msg})
|
|
return
|
|
}
|
|
|
|
rest.CompleteAndBroadcastTxREST(w, r, cliCtx, req.BaseReq, []sdk.Msg{msg}, cdc)
|
|
}
|
|
}
|
|
|
|
func queryParamsHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
paramType := vars[RestParamsType]
|
|
|
|
res, err := cliCtx.QueryWithData(fmt.Sprintf("custom/gov/%s/%s", gov.QueryParams, paramType), nil)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusNotFound, err.Error())
|
|
return
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
func queryProposalHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
|
|
if len(strProposalID) == 0 {
|
|
err := errors.New("proposalId required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
params := gov.NewQueryProposalParams(proposalID)
|
|
|
|
bz, err := cdc.MarshalJSON(params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err := cliCtx.QueryWithData("custom/gov/proposal", bz)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
func queryDepositsHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
params := gov.NewQueryProposalParams(proposalID)
|
|
|
|
bz, err := cdc.MarshalJSON(params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err := cliCtx.QueryWithData("custom/gov/proposal", bz)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
var proposal gov.Proposal
|
|
if err := cdc.UnmarshalJSON(res, &proposal); err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
// For inactive proposals we must query the txs directly to get the deposits
|
|
// as they're no longer in state.
|
|
propStatus := proposal.GetStatus()
|
|
if !(propStatus == gov.StatusVotingPeriod || propStatus == gov.StatusDepositPeriod) {
|
|
res, err = gcutils.QueryDepositsByTxQuery(cdc, cliCtx, params)
|
|
} else {
|
|
res, err = cliCtx.QueryWithData("custom/gov/deposits", bz)
|
|
}
|
|
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
func queryProposerHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
res, err := gcutils.QueryProposerByTxQuery(cdc, cliCtx, proposalID)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
func queryDepositHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
bechDepositorAddr := vars[RestDepositor]
|
|
|
|
if len(strProposalID) == 0 {
|
|
err := errors.New("proposalId required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
if len(bechDepositorAddr) == 0 {
|
|
err := errors.New("depositor address required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
depositorAddr, err := sdk.AccAddressFromBech32(bechDepositorAddr)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
params := gov.NewQueryDepositParams(proposalID, depositorAddr)
|
|
|
|
bz, err := cdc.MarshalJSON(params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err := cliCtx.QueryWithData("custom/gov/deposit", bz)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
var deposit gov.Deposit
|
|
cdc.UnmarshalJSON(res, &deposit)
|
|
|
|
// For an empty deposit, either the proposal does not exist or is inactive in
|
|
// which case the deposit would be removed from state and should be queried
|
|
// for directly via a txs query.
|
|
if deposit.Empty() {
|
|
bz, err := cdc.MarshalJSON(gov.NewQueryProposalParams(proposalID))
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err = cliCtx.QueryWithData("custom/gov/proposal", bz)
|
|
if err != nil || len(res) == 0 {
|
|
err := fmt.Errorf("proposalID %d does not exist", proposalID)
|
|
rest.WriteErrorResponse(w, http.StatusNotFound, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err = gcutils.QueryDepositByTxQuery(cdc, cliCtx, params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
func queryVoteHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
bechVoterAddr := vars[RestVoter]
|
|
|
|
if len(strProposalID) == 0 {
|
|
err := errors.New("proposalId required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
if len(bechVoterAddr) == 0 {
|
|
err := errors.New("voter address required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
voterAddr, err := sdk.AccAddressFromBech32(bechVoterAddr)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
params := gov.NewQueryVoteParams(proposalID, voterAddr)
|
|
|
|
bz, err := cdc.MarshalJSON(params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err := cliCtx.QueryWithData("custom/gov/vote", bz)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
var vote gov.Vote
|
|
cdc.UnmarshalJSON(res, &vote)
|
|
|
|
// For an empty vote, either the proposal does not exist or is inactive in
|
|
// which case the vote would be removed from state and should be queried for
|
|
// directly via a txs query.
|
|
if vote.Empty() {
|
|
bz, err := cdc.MarshalJSON(gov.NewQueryProposalParams(proposalID))
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err = cliCtx.QueryWithData("custom/gov/proposal", bz)
|
|
if err != nil || len(res) == 0 {
|
|
err := fmt.Errorf("proposalID %d does not exist", proposalID)
|
|
rest.WriteErrorResponse(w, http.StatusNotFound, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err = gcutils.QueryVoteByTxQuery(cdc, cliCtx, params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
// todo: Split this functionality into helper functions to remove the above
|
|
func queryVotesOnProposalHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
|
|
if len(strProposalID) == 0 {
|
|
err := errors.New("proposalId required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
params := gov.NewQueryProposalParams(proposalID)
|
|
|
|
bz, err := cdc.MarshalJSON(params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err := cliCtx.QueryWithData("custom/gov/proposal", bz)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
var proposal gov.Proposal
|
|
if err := cdc.UnmarshalJSON(res, &proposal); err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
// For inactive proposals we must query the txs directly to get the votes
|
|
// as they're no longer in state.
|
|
propStatus := proposal.GetStatus()
|
|
if !(propStatus == gov.StatusVotingPeriod || propStatus == gov.StatusDepositPeriod) {
|
|
res, err = gcutils.QueryVotesByTxQuery(cdc, cliCtx, params)
|
|
} else {
|
|
res, err = cliCtx.QueryWithData("custom/gov/votes", bz)
|
|
}
|
|
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
// todo: Split this functionality into helper functions to remove the above
|
|
func queryProposalsWithParameterFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
bechVoterAddr := r.URL.Query().Get(RestVoter)
|
|
bechDepositorAddr := r.URL.Query().Get(RestDepositor)
|
|
strProposalStatus := r.URL.Query().Get(RestProposalStatus)
|
|
strNumLimit := r.URL.Query().Get(RestNumLimit)
|
|
|
|
params := gov.QueryProposalsParams{}
|
|
|
|
if len(bechVoterAddr) != 0 {
|
|
voterAddr, err := sdk.AccAddressFromBech32(bechVoterAddr)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
params.Voter = voterAddr
|
|
}
|
|
|
|
if len(bechDepositorAddr) != 0 {
|
|
depositorAddr, err := sdk.AccAddressFromBech32(bechDepositorAddr)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
params.Depositor = depositorAddr
|
|
}
|
|
|
|
if len(strProposalStatus) != 0 {
|
|
proposalStatus, err := gov.ProposalStatusFromString(govClientUtils.NormalizeProposalStatus(strProposalStatus))
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
params.ProposalStatus = proposalStatus
|
|
}
|
|
if len(strNumLimit) != 0 {
|
|
numLimit, ok := rest.ParseUint64OrReturnBadRequest(w, strNumLimit)
|
|
if !ok {
|
|
return
|
|
}
|
|
params.Limit = numLimit
|
|
}
|
|
|
|
bz, err := cdc.MarshalJSON(params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err := cliCtx.QueryWithData("custom/gov/proposals", bz)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|
|
|
|
// todo: Split this functionality into helper functions to remove the above
|
|
func queryTallyOnProposalHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
vars := mux.Vars(r)
|
|
strProposalID := vars[RestProposalID]
|
|
|
|
if len(strProposalID) == 0 {
|
|
err := errors.New("proposalId required but not specified")
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
proposalID, ok := rest.ParseUint64OrReturnBadRequest(w, strProposalID)
|
|
if !ok {
|
|
return
|
|
}
|
|
|
|
params := gov.NewQueryProposalParams(proposalID)
|
|
|
|
bz, err := cdc.MarshalJSON(params)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
return
|
|
}
|
|
|
|
res, err := cliCtx.QueryWithData("custom/gov/tally", bz)
|
|
if err != nil {
|
|
rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
rest.PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
}
|
|
}
|