Block Time in Txs Response

.pending/improvements/sdk/3238-Add-block-time-to-tx-responses-when-querying-for

@@ -0,0 +1,2 @@
+#3238 Add block time to tx responses when querying for
+txs by tags or hash.

client/tx/query.go

@@ -1,14 +1,13 @@
 package tx
 
 import (
- "encoding/hex"
  "fmt"
  "net/http"
  "strings"
 
  "github.com/gorilla/mux"
  "github.com/spf13/cobra"
- ctypes "github.com/tendermint/tendermint/rpc/core/types"
+ "github.com/tendermint/tendermint/types"
 
  "github.com/spf13/viper"
 
@@ -17,14 +16,100 @@ import (
  "github.com/cosmos/cosmos-sdk/codec"
  sdk "github.com/cosmos/cosmos-sdk/types"
  "github.com/cosmos/cosmos-sdk/types/rest"
- "github.com/cosmos/cosmos-sdk/x/auth"
 )
 
+const (
+ flagTags = "tags"
+ flagPage = "page"
+ flagLimit = "limit"
+)
+
+// ----------------------------------------------------------------------------
+// CLI
+// ----------------------------------------------------------------------------
+
+// SearchTxCmd returns a command to search through tagged transactions.
+func SearchTxCmd(cdc *codec.Codec) *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "txs",
+ Short: "Search for paginated transactions that match a set of tags",
+ Long: strings.TrimSpace(`
+Search for transactions that match the exact given tags where results are paginated.
+
+Example:
+$ gaiacli query txs --tags '<tag1>:<value1>&<tag2>:<value2>' --page 1 --limit 30
+`),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ tagsStr := viper.GetString(flagTags)
+ tagsStr = strings.Trim(tagsStr, "'")
+
+ var tags []string
+ if strings.Contains(tagsStr, "&") {
+ tags = strings.Split(tagsStr, "&")
+ } else {
+ tags = append(tags, tagsStr)
+ }
+
+ var tmTags []string
+ for _, tag := range tags {
+ if !strings.Contains(tag, ":") {
+ return fmt.Errorf("%s should be of the format <key>:<value>", tagsStr)
+ } else if strings.Count(tag, ":") > 1 {
+ return fmt.Errorf("%s should only contain one <key>:<value> pair", tagsStr)
+ }
+
+ keyValue := strings.Split(tag, ":")
+ if keyValue[0] == types.TxHeightKey {
+ tag = fmt.Sprintf("%s=%s", keyValue[0], keyValue[1])
+ } else {
+ tag = fmt.Sprintf("%s='%s'", keyValue[0], keyValue[1])
+ }
+ tmTags = append(tmTags, tag)
+ }
+
+ page := viper.GetInt(flagPage)
+ limit := viper.GetInt(flagLimit)
+
+ cliCtx := context.NewCLIContext().WithCodec(cdc)
+ txs, err := SearchTxs(cliCtx, cdc, tmTags, page, limit)
+ if err != nil {
+ return err
+ }
+
+ var output []byte
+ if cliCtx.Indent {
+ output, err = cdc.MarshalJSONIndent(txs, "", " ")
+ } else {
+ output, err = cdc.MarshalJSON(txs)
+ }
+
+ if err != nil {
+ return err
+ }
+
+ fmt.Println(string(output))
+ return nil
+ },
+ }
+
+ cmd.Flags().StringP(client.FlagNode, "n", "tcp://localhost:26657", "Node to connect to")
+ viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
+ cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
+ viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
+
+ cmd.Flags().String(flagTags, "", "tag:value list of tags that must match")
+ cmd.Flags().Int32(flagPage, rest.DefaultPage, "Query a specific page of paginated results")
+ cmd.Flags().Int32(flagLimit, rest.DefaultLimit, "Query number of transactions results per page returned")
+ cmd.MarkFlagRequired(flagTags)
+
+ return cmd
+}
+
 // QueryTxCmd implements the default command for a tx query.
 func QueryTxCmd(cdc *codec.Codec) *cobra.Command {
  cmd := &cobra.Command{
  Use: "tx [hash]",
- Short: "Matches this txhash over all committed blocks",
+ Short: "Find a transaction by hash in a committed block.",
  Args: cobra.ExactArgs(1),
  RunE: func(cmd *cobra.Command, args []string) error {
  cliCtx := context.NewCLIContext().WithCodec(cdc)
@@ -46,76 +131,55 @@ func QueryTxCmd(cdc *codec.Codec) *cobra.Command {
  viper.BindPFlag(client.FlagNode, cmd.Flags().Lookup(client.FlagNode))
  cmd.Flags().Bool(client.FlagTrustNode, false, "Trust connected full node (don't verify proofs for responses)")
  viper.BindPFlag(client.FlagTrustNode, cmd.Flags().Lookup(client.FlagTrustNode))
+
  return cmd
 }
 
-func queryTx(cdc *codec.Codec, cliCtx context.CLIContext, hashHexStr string) (out sdk.TxResponse, err error) {
- hash, err := hex.DecodeString(hashHexStr)
- if err != nil {
- return out, err
- }
-
- node, err := cliCtx.GetNode()
- if err != nil {
- return out, err
- }
+// ----------------------------------------------------------------------------
+// REST
+// ----------------------------------------------------------------------------
 
- res, err := node.Tx(hash, !cliCtx.TrustNode)
- if err != nil {
- return out, err
- }
+// QueryTxsByTagsRequestHandlerFn implements a REST handler that searches for
+// transactions by tags.
+func QueryTxsByTagsRequestHandlerFn(cliCtx context.CLIContext, cdc *codec.Codec) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ var (
+ tags []string
+ txs []sdk.TxResponse
+ page, limit int
+ )
 
- if !cliCtx.TrustNode {
- if err = ValidateTxResult(cliCtx, res); err != nil {
- return out, err
+ err := r.ParseForm()
+ if err != nil {
+ rest.WriteErrorResponse(w, http.StatusBadRequest,
+ sdk.AppendMsgToErr("could not parse query parameters", err.Error()))
+ return
  }
- }
 
- if out, err = formatTxResult(cdc, res); err != nil {
- return out, err
- }
+ if len(r.Form) == 0 {
+ rest.PostProcessResponse(w, cdc, txs, cliCtx.Indent)
+ return
+ }
 
- return out, nil
-}
+ tags, page, limit, err = rest.ParseHTTPArgs(r)
 
-// ValidateTxResult performs transaction verification
-func ValidateTxResult(cliCtx context.CLIContext, res *ctypes.ResultTx) error {
- if !cliCtx.TrustNode {
- check, err := cliCtx.Verify(res.Height)
  if err != nil {
- return err
+ rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error())
+ return
  }
- err = res.Proof.Validate(check.Header.DataHash)
+
+ txs, err = SearchTxs(cliCtx, cdc, tags, page, limit)
  if err != nil {
- return err
+ rest.WriteErrorResponse(w, http.StatusInternalServerError, err.Error())
+ return
  }
- }
- return nil
-}
 
-func formatTxResult(cdc *codec.Codec, res *ctypes.ResultTx) (sdk.TxResponse, error) {
- tx, err := parseTx(cdc, res.Tx)
- if err != nil {
- return sdk.TxResponse{}, err
+ rest.PostProcessResponse(w, cdc, txs, cliCtx.Indent)
  }
-
- return sdk.NewResponseResultTx(res, tx), nil
 }
 
-func parseTx(cdc *codec.Codec, txBytes []byte) (sdk.Tx, error) {
- var tx auth.StdTx
-
- err := cdc.UnmarshalBinaryLengthPrefixed(txBytes, &tx)
- if err != nil {
- return nil, err
- }
-
- return tx, nil
-}
-
-// REST
-
-// QueryTxRequestHandlerFn transaction query REST handler
+// QueryTxRequestHandlerFn implements a REST handler that queries a transaction
+// by hash in a committed block.
 func QueryTxRequestHandlerFn(cdc *codec.Codec, cliCtx context.CLIContext) http.HandlerFunc {
  return func(w http.ResponseWriter, r *http.Request) {
  vars := mux.Vars(r)

client/tx/root.go

@@ -10,7 +10,7 @@ import (
 // register REST routes
 func RegisterRoutes(cliCtx context.CLIContext, r *mux.Router, cdc *codec.Codec) {
  r.HandleFunc("/txs/{hash}", QueryTxRequestHandlerFn(cdc, cliCtx)).Methods("GET")
- r.HandleFunc("/txs", SearchTxRequestHandlerFn(cliCtx, cdc)).Methods("GET")
+ r.HandleFunc("/txs", QueryTxsByTagsRequestHandlerFn(cliCtx, cdc)).Methods("GET")
  r.HandleFunc("/txs", BroadcastTxRequest(cliCtx, cdc)).Methods("POST")
  r.HandleFunc("/txs/encode", EncodeTxRequestHandlerFn(cdc, cliCtx)).Methods("POST")
 }