2019-02-04 07:48:26 -08:00
|
|
|
package rest
|
2018-08-22 04:38:55 -07:00
|
|
|
|
|
|
|
import (
|
2018-08-31 10:04:11 -07:00
|
|
|
"fmt"
|
2018-08-22 04:38:55 -07:00
|
|
|
"net/http"
|
2018-08-31 10:04:42 -07:00
|
|
|
"strconv"
|
2018-09-02 11:20:14 -07:00
|
|
|
|
2018-10-04 04:00:24 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/client"
|
2018-09-26 06:29:39 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/client/context"
|
2019-02-04 07:48:26 -08:00
|
|
|
"github.com/cosmos/cosmos-sdk/client/utils"
|
2018-09-26 06:29:39 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
2018-10-24 06:19:48 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/crypto/keys/keyerror"
|
2018-09-02 11:20:14 -07:00
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
2018-10-04 04:00:24 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/x/auth"
|
2018-09-07 10:04:58 -07:00
|
|
|
authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
|
2018-08-22 04:38:55 -07:00
|
|
|
)
|
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
//-----------------------------------------------------------------------------
|
2018-09-26 06:29:39 -07:00
|
|
|
// Basic HTTP utilities
|
|
|
|
|
2019-02-03 20:52:08 -08:00
|
|
|
// ErrorResponse defines the attributes of a JSON error response.
|
|
|
|
type ErrorResponse struct {
|
|
|
|
Code int `json:"code,omitempty"`
|
|
|
|
Message string `json:"message"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewErrorResponse creates a new ErrorResponse instance.
|
|
|
|
func NewErrorResponse(code int, msg string) ErrorResponse {
|
|
|
|
return ErrorResponse{Code: code, Message: msg}
|
|
|
|
}
|
|
|
|
|
2018-08-22 04:38:55 -07:00
|
|
|
// WriteErrorResponse prepares and writes a HTTP error
|
|
|
|
// given a status code and an error message.
|
2018-10-19 09:55:20 -07:00
|
|
|
func WriteErrorResponse(w http.ResponseWriter, status int, err string) {
|
2019-02-03 20:52:08 -08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2018-08-31 08:10:09 -07:00
|
|
|
w.WriteHeader(status)
|
2019-02-03 20:52:08 -08:00
|
|
|
w.Write(codec.Cdc.MustMarshalJSON(NewErrorResponse(0, err)))
|
2018-08-22 04:38:55 -07:00
|
|
|
}
|
2018-08-31 10:04:11 -07:00
|
|
|
|
2018-10-19 09:55:20 -07:00
|
|
|
// WriteSimulationResponse prepares and writes an HTTP
|
2018-08-31 10:04:11 -07:00
|
|
|
// response for transactions simulations.
|
2019-01-29 11:22:47 -08:00
|
|
|
func WriteSimulationResponse(w http.ResponseWriter, cdc *codec.Codec, gas uint64) {
|
|
|
|
gasEst := GasEstimateResponse{GasEstimate: gas}
|
|
|
|
resp, err := cdc.MarshalJSON(gasEst)
|
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2018-08-31 08:10:09 -07:00
|
|
|
w.WriteHeader(http.StatusOK)
|
2019-01-29 11:22:47 -08:00
|
|
|
w.Write(resp)
|
2018-08-31 10:04:11 -07:00
|
|
|
}
|
|
|
|
|
2018-09-26 06:29:39 -07:00
|
|
|
// ParseInt64OrReturnBadRequest converts s to a int64 value.
|
|
|
|
func ParseInt64OrReturnBadRequest(w http.ResponseWriter, s string) (n int64, ok bool) {
|
|
|
|
var err error
|
2018-09-02 11:20:14 -07:00
|
|
|
|
2018-09-26 06:29:39 -07:00
|
|
|
n, err = strconv.ParseInt(s, 10, 64)
|
|
|
|
if err != nil {
|
|
|
|
err := fmt.Errorf("'%s' is not a valid int64", s)
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return n, false
|
2018-11-06 23:33:18 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
return n, true
|
|
|
|
}
|
|
|
|
|
|
|
|
// ParseUint64OrReturnBadRequest converts s to a uint64 value.
|
|
|
|
func ParseUint64OrReturnBadRequest(w http.ResponseWriter, s string) (n uint64, ok bool) {
|
|
|
|
var err error
|
|
|
|
|
|
|
|
n, err = strconv.ParseUint(s, 10, 64)
|
|
|
|
if err != nil {
|
|
|
|
err := fmt.Errorf("'%s' is not a valid uint64", s)
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return n, false
|
2018-09-26 06:29:39 -07:00
|
|
|
}
|
2018-08-31 10:04:42 -07:00
|
|
|
|
2018-09-26 06:29:39 -07:00
|
|
|
return n, true
|
|
|
|
}
|
|
|
|
|
|
|
|
// ParseFloat64OrReturnBadRequest converts s to a float64 value. It returns a
|
|
|
|
// default value, defaultIfEmpty, if the string is empty.
|
2018-08-31 08:10:09 -07:00
|
|
|
func ParseFloat64OrReturnBadRequest(w http.ResponseWriter, s string, defaultIfEmpty float64) (n float64, ok bool) {
|
2018-08-31 10:04:42 -07:00
|
|
|
if len(s) == 0 {
|
|
|
|
return defaultIfEmpty, true
|
|
|
|
}
|
2018-09-26 06:29:39 -07:00
|
|
|
|
2018-08-31 10:04:42 -07:00
|
|
|
n, err := strconv.ParseFloat(s, 64)
|
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return n, false
|
|
|
|
}
|
2018-09-26 06:29:39 -07:00
|
|
|
|
2018-08-31 10:04:42 -07:00
|
|
|
return n, true
|
|
|
|
}
|
2018-09-02 11:20:14 -07:00
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
//-----------------------------------------------------------------------------
|
2018-09-26 06:29:39 -07:00
|
|
|
// Building / Sending utilities
|
|
|
|
|
|
|
|
// CompleteAndBroadcastTxREST implements a utility function that facilitates
|
2019-01-29 11:22:47 -08:00
|
|
|
// sending a series of messages in a signed tx. In addition, it will handle
|
|
|
|
// tx gas simulation and estimation.
|
2018-09-26 06:29:39 -07:00
|
|
|
//
|
2019-01-29 11:22:47 -08:00
|
|
|
// NOTE: Also see CompleteAndBroadcastTxCLI.
|
2019-01-18 08:45:20 -08:00
|
|
|
func CompleteAndBroadcastTxREST(
|
|
|
|
w http.ResponseWriter, r *http.Request, cliCtx context.CLIContext,
|
|
|
|
baseReq BaseReq, msgs []sdk.Msg, cdc *codec.Codec,
|
|
|
|
) {
|
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
gasAdj, ok := ParseFloat64OrReturnBadRequest(w, baseReq.GasAdjustment, client.DefaultGasAdjustment)
|
2018-12-19 16:26:33 -08:00
|
|
|
if !ok {
|
2018-09-26 06:29:39 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
simAndExec, gas, err := client.ParseGas(baseReq.Gas)
|
2018-12-19 16:26:33 -08:00
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
2018-09-26 06:29:39 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
// derive the from account address and name from the Keybase
|
|
|
|
fromAddress, fromName, err := context.GetFromFields(baseReq.From)
|
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
cliCtx = cliCtx.WithFromName(fromName).WithFromAddress(fromAddress)
|
2019-01-18 08:45:20 -08:00
|
|
|
txBldr := authtxb.NewTxBuilder(
|
2019-02-04 07:48:26 -08:00
|
|
|
utils.GetTxEncoder(cdc), baseReq.AccountNumber,
|
2019-01-29 11:22:47 -08:00
|
|
|
baseReq.Sequence, gas, gasAdj, baseReq.Simulate,
|
2019-01-18 08:45:20 -08:00
|
|
|
baseReq.ChainID, baseReq.Memo, baseReq.Fees, baseReq.GasPrices,
|
|
|
|
)
|
2018-12-19 16:26:33 -08:00
|
|
|
|
2019-02-04 07:48:26 -08:00
|
|
|
txBldr, err = utils.PrepareTxBuilder(txBldr, cliCtx)
|
2019-01-29 11:22:47 -08:00
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if baseReq.Simulate || simAndExec {
|
|
|
|
if gasAdj < 0 {
|
2019-02-01 17:04:13 -08:00
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, client.ErrInvalidGasAdjustment.Error())
|
2018-12-19 16:26:33 -08:00
|
|
|
return
|
|
|
|
}
|
2018-09-26 06:29:39 -07:00
|
|
|
|
2019-02-04 07:48:26 -08:00
|
|
|
txBldr, err = utils.EnrichWithGas(txBldr, cliCtx, msgs)
|
2018-09-26 06:29:39 -07:00
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-12-10 06:26:34 -08:00
|
|
|
if baseReq.Simulate {
|
2019-02-06 11:23:49 -08:00
|
|
|
WriteSimulationResponse(w, cdc, txBldr.Gas())
|
2018-09-26 06:29:39 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
txBytes, err := txBldr.BuildAndSign(cliCtx.GetFromName(), baseReq.Password, msgs)
|
2018-10-24 06:19:48 -07:00
|
|
|
if keyerror.IsErrKeyNotFound(err) {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return
|
|
|
|
} else if keyerror.IsErrWrongPassword(err) {
|
2018-09-26 06:29:39 -07:00
|
|
|
WriteErrorResponse(w, http.StatusUnauthorized, err.Error())
|
|
|
|
return
|
2018-10-24 06:19:48 -07:00
|
|
|
} else if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
|
|
return
|
2018-09-26 06:29:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
res, err := cliCtx.BroadcastTx(txBytes)
|
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-10-04 04:00:24 -07:00
|
|
|
PostProcessResponse(w, cdc, res, cliCtx.Indent)
|
|
|
|
}
|
2018-09-26 06:29:39 -07:00
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
// PostProcessResponse performs post processing for a REST response.
|
2018-10-04 04:00:24 -07:00
|
|
|
func PostProcessResponse(w http.ResponseWriter, cdc *codec.Codec, response interface{}, indent bool) {
|
|
|
|
var output []byte
|
2019-01-29 11:22:47 -08:00
|
|
|
|
2018-10-04 04:00:24 -07:00
|
|
|
switch response.(type) {
|
|
|
|
default:
|
|
|
|
var err error
|
|
|
|
if indent {
|
|
|
|
output, err = cdc.MarshalJSONIndent(response, "", " ")
|
|
|
|
} else {
|
|
|
|
output, err = cdc.MarshalJSON(response)
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
case []byte:
|
|
|
|
output = response.([]byte)
|
|
|
|
}
|
2019-01-29 11:22:47 -08:00
|
|
|
|
2018-10-04 04:00:24 -07:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2018-09-26 06:29:39 -07:00
|
|
|
w.Write(output)
|
|
|
|
}
|
2019-01-29 11:22:47 -08:00
|
|
|
|
|
|
|
// WriteGenerateStdTxResponse writes response for the generate only mode.
|
2019-02-01 17:04:13 -08:00
|
|
|
func WriteGenerateStdTxResponse(
|
|
|
|
w http.ResponseWriter, cdc *codec.Codec, cliCtx context.CLIContext, br BaseReq, msgs []sdk.Msg,
|
|
|
|
) {
|
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
gasAdj, ok := ParseFloat64OrReturnBadRequest(w, br.GasAdjustment, client.DefaultGasAdjustment)
|
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-02-01 17:04:13 -08:00
|
|
|
simAndExec, gas, err := client.ParseGas(br.Gas)
|
2019-01-29 11:22:47 -08:00
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
txBldr := authtxb.NewTxBuilder(
|
2019-02-04 07:48:26 -08:00
|
|
|
utils.GetTxEncoder(cdc), br.AccountNumber, br.Sequence, gas, gasAdj,
|
2019-01-29 11:22:47 -08:00
|
|
|
br.Simulate, br.ChainID, br.Memo, br.Fees, br.GasPrices,
|
|
|
|
)
|
|
|
|
|
2019-02-01 17:04:13 -08:00
|
|
|
if simAndExec {
|
|
|
|
if gasAdj < 0 {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, client.ErrInvalidGasAdjustment.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-02-04 07:48:26 -08:00
|
|
|
txBldr, err = utils.EnrichWithGas(txBldr, cliCtx, msgs)
|
2019-02-01 17:04:13 -08:00
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-01-29 11:22:47 -08:00
|
|
|
stdMsg, err := txBldr.Build(msgs)
|
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusBadRequest, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
output, err := cdc.MarshalJSON(auth.NewStdTx(stdMsg.Msgs, stdMsg.Fee, nil, stdMsg.Memo))
|
|
|
|
if err != nil {
|
|
|
|
WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-02-03 20:52:08 -08:00
|
|
|
w.Header().Set("Content-Type", "application/json")
|
2019-01-29 11:22:47 -08:00
|
|
|
w.Write(output)
|
|
|
|
return
|
|
|
|
}
|