Add governance and slashing, implement post /txs api

client/context/query.go

@@ -164,6 +164,22 @@ func (ctx CLIContext) BroadcastTxAsync(tx []byte) (*ctypes.ResultBroadcastTx, er
 	return res, err
 }
 
+// BroadcastTxSync broadcasts transaction bytes to a Tendermint node
+// synchronously.
+func (ctx CLIContext) BroadcastTxSync(tx []byte) (*ctypes.ResultBroadcastTx, error) {
+	node, err := ctx.GetNode()
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := node.BroadcastTxSync(tx)
+	if err != nil {
+		return res, err
+	}
+
+	return res, err
+}
+
 // EnsureAccountExists ensures that an account exists for a given context. An
 // error is returned if it does not.
 func (ctx CLIContext) EnsureAccountExists() error {

client/lcd/root.go

@@ -47,7 +47,7 @@ func ServeCommand(cdc *wire.Codec) *cobra.Command {
 			staticServer := http.FileServer(statikFS)
 			router.PathPrefix("/swaggerui/").Handler(http.StripPrefix("/swaggerui/", staticServer))
 
-			logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "rest-server")
+			logger := log.NewTMLogger(log.NewSyncWriter(os.Stdout)).With("module", "lite-server")
 			maxOpen := viper.GetInt(flagMaxOpenConnections)
 
 			listener, err := tmserver.StartHTTPServer(

client/tx/broadcast.go

@@ -1,37 +1,89 @@
 package tx
 
 import (
-	"encoding/json"
 	"net/http"
 
 	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/wire"
+	"io/ioutil"
+)
+
+const (
+	flagSync  = "sync"
+	flagAsync = "async"
+	flagBlock = "block"
 )
 
 // Tx Broadcast Body
-type BroadcastTxBody struct {
-	TxBytes string `json:"tx"`
+// BroadcastBody contains the data of tx and specify how to broadcast tx
+type BroadcastBody struct {
+	Transaction string `json:"transaction"`
+	Return      string `json:"return"`
 }
 
 // BroadcastTx REST Handler
-func BroadcastTxRequestHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+func BroadcastTxRequestHandlerFn(cdc *wire.Codec, ctx context.CLIContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		var m BroadcastTxBody
-
-		decoder := json.NewDecoder(r.Body)
-		err := decoder.Decode(&m)
+		var txBody BroadcastBody
+		body, err := ioutil.ReadAll(r.Body)
 		if err != nil {
-			w.WriteHeader(400)
+			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
 			return
 		}
-
-		res, err := cliCtx.BroadcastTx([]byte(m.TxBytes))
+		err = cdc.UnmarshalJSON(body, &txBody)
 		if err != nil {
-			w.WriteHeader(500)
+			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte(err.Error()))
 			return
 		}
-
-		w.Write([]byte(string(res.Height)))
+		var output []byte
+		switch txBody.Return {
+		case flagBlock:
+			res, err := ctx.BroadcastTx([]byte(txBody.Transaction))
+			if err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				w.Write([]byte(err.Error()))
+				return
+			}
+			output, err = cdc.MarshalJSON(res)
+			if err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				w.Write([]byte(err.Error()))
+				return
+			}
+		case flagSync:
+			res, err := ctx.BroadcastTxSync([]byte(txBody.Transaction))
+			if err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				w.Write([]byte(err.Error()))
+				return
+			}
+			output, err = cdc.MarshalJSON(res)
+			if err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				w.Write([]byte(err.Error()))
+				return
+			}
+		case flagAsync:
+			res, err := ctx.BroadcastTxAsync([]byte(txBody.Transaction))
+			if err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				w.Write([]byte(err.Error()))
+				return
+			}
+			output, err = cdc.MarshalJSON(res)
+			if err != nil {
+				w.WriteHeader(http.StatusInternalServerError)
+				w.Write([]byte(err.Error()))
+				return
+			}
+		default:
+			w.WriteHeader(http.StatusInternalServerError)
+			w.Write([]byte("unsupported return type. supported types: block, sync, async"))
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		w.Write(output)
 	}
 }

client/tx/root.go

@@ -21,5 +21,5 @@ func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *wire.Codec) {
 	r.HandleFunc("/txs/{hash}", QueryTxRequestHandlerFn(cdc, cliCtx)).Methods("GET")
 	r.HandleFunc("/txs", SearchTxRequestHandlerFn(cliCtx, cdc)).Methods("GET")
 	// r.HandleFunc("/txs/sign", SignTxRequstHandler).Methods("POST")
-	// r.HandleFunc("/txs/broadcast", BroadcastTxRequestHandler).Methods("POST")
+	r.HandleFunc("/txs", BroadcastTxRequestHandlerFn(cdc, cliCtx)).Methods("POST")
 }