Add IBC REST endpoints

types/rest/rest.go

@@ -375,3 +375,14 @@ func ParseHTTPArgsWithLimit(r *http.Request, defaultLimit int) (tags []string, p
 func ParseHTTPArgs(r *http.Request) (tags []string, page, limit int, err error) {
 	return ParseHTTPArgsWithLimit(r, DefaultLimit)
 }
+
+// ParseQueryProve sets the prove to execute a query if set by the http request.
+// It returns false if there was an error parsing the prove.
+func ParseQueryProve(r *http.Request) bool {
+	proveStr := r.FormValue("prove")
+	prove := false
+	if ok, err := strconv.ParseBool(proveStr); err == nil {
+		prove = ok
+	}
+	return prove
+}

x/ibc/02-client/client/rest/query.go

@@ -0,0 +1,185 @@
+package rest
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/gorilla/mux"
+	abci "github.com/tendermint/tendermint/abci/types"
+	tmtypes "github.com/tendermint/tendermint/types"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/types/rest"
+	"github.com/cosmos/cosmos-sdk/x/ibc/02-client/client/utils"
+	"github.com/cosmos/cosmos-sdk/x/ibc/02-client/types"
+	"github.com/cosmos/cosmos-sdk/x/ibc/02-client/types/tendermint"
+	commitment "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment"
+)
+
+func registerQueryRoutes(cliCtx context.CLIContext, r *mux.Router, queryRoute string) {
+	r.HandleFunc(fmt.Sprintf("/ibc/clients/{%s}/consensus-state", RestClientID), queryConsensusStateHandlerFn(cliCtx, queryRoute)).Methods("GET")
+	r.HandleFunc(fmt.Sprintf("/ibc/clients/{%s}/client-state", RestClientID), queryClientStateHandlerFn(cliCtx, queryRoute)).Methods("GET")
+	r.HandleFunc(fmt.Sprintf("/ibc/clients/{%s}/roots/{%s}", RestClientID, RestRootHeight), queryRootHandlerFn(cliCtx, queryRoute)).Methods("GET")
+	r.HandleFunc("/ibc/header", queryHeaderHandlerFn(cliCtx)).Methods("GET")
+	r.HandleFunc("/ibc/node-state", queryNodeConsensusStateHandlerFn(cliCtx)).Methods("GET")
+	r.HandleFunc("/ibc/path", queryPathHandlerFn(cliCtx)).Methods("GET")
+}
+
+func queryConsensusStateHandlerFn(cliCtx context.CLIContext, queryRoute string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		clientID := vars[RestClientID]
+
+		cliCtx, ok := rest.ParseQueryHeightOrReturnBadRequest(w, cliCtx, r)
+		if !ok {
+			return
+		}
+
+		req := abci.RequestQuery{
+			Path:  "store/ibc/key",
+			Data:  types.KeyConsensusState(clientID),
+			Prove: rest.ParseQueryProve(r),
+		}
+
+		res, err := cliCtx.QueryABCI(req)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		var cs tendermint.ConsensusState
+		if err := cliCtx.Codec.UnmarshalBinaryLengthPrefixed(res.Value, &cs); err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+		}
+
+		cliCtx = cliCtx.WithHeight(res.Height)
+		rest.PostProcessResponse(w, cliCtx, types.NewConsensusStateResponse(clientID, cs, res.Proof, res.Height))
+	}
+}
+
+func queryHeaderHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		header, err := utils.GetTendermintHeader(cliCtx)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		rest.PostProcessResponse(w, cliCtx, header)
+	}
+}
+
+func queryClientStateHandlerFn(cliCtx context.CLIContext, queryRoute string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		clientID := vars[RestClientID]
+
+		cliCtx, ok := rest.ParseQueryHeightOrReturnBadRequest(w, cliCtx, r)
+		if !ok {
+			return
+		}
+
+		req := abci.RequestQuery{
+			Path:  "store/ibc/key",
+			Data:  types.KeyClientState(clientID),
+			Prove: rest.ParseQueryProve(r),
+		}
+
+		res, err := cliCtx.QueryABCI(req)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		var state types.State
+		if err := cliCtx.Codec.UnmarshalBinaryLengthPrefixed(res.Value, &state); err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+		}
+
+		cliCtx = cliCtx.WithHeight(res.Height)
+		rest.PostProcessResponse(w, cliCtx, types.NewClientStateResponse(clientID, state, res.Proof, res.Height))
+	}
+}
+
+func queryRootHandlerFn(cliCtx context.CLIContext, queryRoute string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		clientID := vars[RestClientID]
+		height, err := strconv.ParseUint(vars[RestRootHeight], 10, 64)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		cliCtx, ok := rest.ParseQueryHeightOrReturnBadRequest(w, cliCtx, r)
+		if !ok {
+			return
+		}
+
+		bz, err := cliCtx.Codec.MarshalJSON(types.NewQueryCommitmentRootParams(clientID, height))
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		res, resHeight, err := cliCtx.QueryWithData(fmt.Sprintf("custom/%s/%s", queryRoute, types.QueryVerifiedRoot), bz)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		cliCtx = cliCtx.WithHeight(resHeight)
+		rest.PostProcessResponse(w, cliCtx, res)
+	}
+}
+
+func queryNodeConsensusStateHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		node, err := cliCtx.GetNode()
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		info, err := node.ABCIInfo()
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		height := info.Response.LastBlockHeight
+		prevHeight := height - 1
+
+		commit, err := node.Commit(&height)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		validators, err := node.Validators(&prevHeight)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+
+		state := tendermint.ConsensusState{
+			ChainID:          commit.ChainID,
+			Height:           uint64(commit.Height),
+			Root:             commitment.NewRoot(commit.AppHash),
+			NextValidatorSet: tmtypes.NewValidatorSet(validators.Validators),
+		}
+
+		res := cliCtx.Codec.MustMarshalJSON(state)
+		cliCtx = cliCtx.WithHeight(height)
+		rest.PostProcessResponse(w, cliCtx, res)
+	}
+}
+
+func queryPathHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		path := commitment.NewPrefix([]byte("ibc"))
+		res := cliCtx.Codec.MustMarshalJSON(path)
+		rest.PostProcessResponse(w, cliCtx, res)
+	}
+}

x/ibc/02-client/client/rest/rest.go

@@ -0,0 +1,39 @@
+package rest
+
+import (
+	"github.com/gorilla/mux"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	"github.com/cosmos/cosmos-sdk/types/rest"
+	"github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported"
+)
+
+const (
+	RestClientID   = "client-id"
+	RestRootHeight = "height"
+)
+
+// RegisterRoutes - Central function to define routes that get registered by the main application
+func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, queryRoute string) {
+	registerQueryRoutes(cliCtx, r, queryRoute)
+	registerTxRoutes(cliCtx, r)
+}
+
+// CreateClientReq defines the properties of a create client request's body.
+type CreateClientReq struct {
+	BaseReq        rest.BaseReq            `json:"base_req" yaml:"base_req"`
+	ClientID       string                  `json:"client_id" yaml:"client_id"`
+	ConsensusState exported.ConsensusState `json:"consensus_state" yaml:"consensus_state"`
+}
+
+// UpdateClientReq defines the properties of a update client request's body.
+type UpdateClientReq struct {
+	BaseReq rest.BaseReq    `json:"base_req" yaml:"base_req"`
+	Header  exported.Header `json:"header" yaml:"header"`
+}
+
+// SubmitMisbehaviourReq defines the properties of a submit misbehaviour request's body.
+type SubmitMisbehaviourReq struct {
+	BaseReq  rest.BaseReq      `json:"base_req" yaml:"base_req"`
+	Evidence exported.Evidence `json:"evidence" yaml:"evidence"`
+}

x/ibc/02-client/client/rest/tx.go

@@ -0,0 +1,130 @@
+package rest
+
+import (
+	"fmt"
+	"net/http"
+
+	"github.com/gorilla/mux"
+
+	"github.com/cosmos/cosmos-sdk/client/context"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/rest"
+	"github.com/cosmos/cosmos-sdk/x/auth/client/utils"
+	"github.com/cosmos/cosmos-sdk/x/ibc/02-client/types"
+)
+
+// RegisterRoutes - Central function to define routes that get registered by the main application
+func registerTxRoutes(cliCtx context.CLIContext, r *mux.Router) {
+	r.HandleFunc("/ibc/clients", createClientHandlerFn(cliCtx)).Methods("POST")
+	r.HandleFunc(fmt.Sprintf("/ibc/clients/{%s}/update", RestClientID), updateClientHandlerFn(cliCtx)).Methods("POST")
+	r.HandleFunc(fmt.Sprintf("/ibc/clients/{%s}/misbehaviour", RestClientID), submitMisbehaviourHandlerFn(cliCtx)).Methods("POST")
+}
+
+func createClientHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		var req CreateClientReq
+		if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) {
+			return
+		}
+
+		req.BaseReq = req.BaseReq.Sanitize()
+		if !req.BaseReq.ValidateBasic(w) {
+			return
+		}
+
+		fromAddr, err := sdk.AccAddressFromBech32(req.BaseReq.From)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		// create the message
+		msg := types.NewMsgCreateClient(
+			req.ClientID,
+			req.ConsensusState.ClientType().String(),
+			req.ConsensusState,
+			fromAddr,
+		)
+
+		if err := msg.ValidateBasic(); err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		utils.WriteGenerateStdTxResponse(w, cliCtx, req.BaseReq, []sdk.Msg{msg})
+	}
+}
+
+func updateClientHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		clientID := vars[RestClientID]
+
+		var req UpdateClientReq
+		if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) {
+			return
+		}
+
+		req.BaseReq = req.BaseReq.Sanitize()
+		if !req.BaseReq.ValidateBasic(w) {
+			return
+		}
+
+		fromAddr, err := sdk.AccAddressFromBech32(req.BaseReq.From)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		// create the message
+		msg := types.NewMsgUpdateClient(
+			clientID,
+			req.Header,
+			fromAddr,
+		)
+
+		if err := msg.ValidateBasic(); err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		utils.WriteGenerateStdTxResponse(w, cliCtx, req.BaseReq, []sdk.Msg{msg})
+	}
+}
+
+func submitMisbehaviourHandlerFn(cliCtx context.CLIContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		vars := mux.Vars(r)
+		clientID := vars[RestClientID]
+
+		var req SubmitMisbehaviourReq
+		if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) {
+			return
+		}
+
+		req.BaseReq = req.BaseReq.Sanitize()
+		if !req.BaseReq.ValidateBasic(w) {
+			return
+		}
+
+		fromAddr, err := sdk.AccAddressFromBech32(req.BaseReq.From)
+		if err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		// create the message
+		msg := types.NewMsgSubmitMisbehaviour(
+			clientID,
+			req.Evidence,
+			fromAddr,
+		)
+
+		if err := msg.ValidateBasic(); err != nil {
+			rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+			return
+		}
+
+		utils.WriteGenerateStdTxResponse(w, cliCtx, req.BaseReq, []sdk.Msg{msg})
+	}
+}

x/ibc/02-client/module.go

@@ -9,6 +9,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/x/ibc/02-client/client/cli"
+	"github.com/cosmos/cosmos-sdk/x/ibc/02-client/client/rest"
 )
 
 // Name returns the IBC client name
@@ -17,8 +18,8 @@ func Name() string {
 }
 
 // RegisterRESTRoutes registers the REST routes for the IBC client
-func RegisterRESTRoutes(ctx context.CLIContext, rtr *mux.Router) {
-	// TODO:
+func RegisterRESTRoutes(ctx context.CLIContext, rtr *mux.Router, queryRoute string) {
+	rest.RegisterRoutes(ctx, rtr, fmt.Sprintf("%s/%s", queryRoute, SubModuleName))
 }
 
 // GetTxCmd returns the root tx command for the IBC client