feat(tm2): store tx results and add endpoint to query them

tm2/pkg/bft/rpc/client/httpclient.go

@@ -307,11 +307,10 @@
 	return result, nil
 }
 
-func (c *baseRPCClient) Tx(hash []byte, prove bool) (*ctypes.ResultTx, error) {
+func (c *baseRPCClient) Tx(hash []byte) (*ctypes.ResultTx, error) {
 	result := new(ctypes.ResultTx)
 	params := map[string]interface{}{
-		"hash":  hash,
-		"prove": prove,
+		"hash": hash,
 	}
 	_, err := c.caller.Call("tx", params, result)
 	if err != nil {
@@ -320,21 +319,6 @@
 	return result, nil
 }
 
-func (c *baseRPCClient) TxSearch(query string, prove bool, page, perPage int) (*ctypes.ResultTxSearch, error) {
-	result := new(ctypes.ResultTxSearch)
-	params := map[string]interface{}{
-		"query":    query,
-		"prove":    prove,
-		"page":     page,
-		"per_page": perPage,
-	}
-	_, err := c.caller.Call("tx_search", params, result)
-	if err != nil {
-		return nil, errors.Wrap(err, "TxSearch")
-	}
-	return result, nil
-}
-
 func (c *baseRPCClient) Validators(height *int64) (*ctypes.ResultValidators, error) {
 	result := new(ctypes.ResultValidators)
 	params := map[string]interface{}{}

tm2/pkg/bft/rpc/client/interface.go

@@ -32,13 +32,13 @@ import (
 // first synchronously consumes the events from the node's synchronous event
 // switch, or reads logged events from the filesystem.
 type Client interface {
-	// service.Service
 	ABCIClient
 	HistoryClient
 	NetworkClient
 	SignClient
 	StatusClient
 	MempoolClient
+	TxClient
 }
 
 // ABCIClient groups together the functionality that principally affects the
@@ -94,3 +94,7 @@ type MempoolClient interface {
 	UnconfirmedTxs(limit int) (*ctypes.ResultUnconfirmedTxs, error)
 	NumUnconfirmedTxs() (*ctypes.ResultUnconfirmedTxs, error)
 }
+
+type TxClient interface {
+	Tx(hash []byte) (*ctypes.ResultTx, error)
+}

tm2/pkg/bft/rpc/client/localclient.go

@@ -137,12 +137,6 @@
 	return core.Validators(c.ctx, height)
 }
 
-/*
-func (c *Local) Tx(hash []byte, prove bool) (*ctypes.ResultTx, error) {
-	return core.Tx(c.ctx, hash, prove)
-}
-
-func (c *Local) TxSearch(query string, prove bool, page, perPage int) (*ctypes.ResultTxSearch, error) {
-	return core.TxSearch(c.ctx, query, prove, page, perPage)
+func (c *Local) Tx(hash []byte) (*ctypes.ResultTx, error) {
+	return core.Tx(c.ctx, hash)
 }
-*/

tm2/pkg/bft/rpc/client/mock/client.go

@@ -36,6 +36,7 @@ type Client struct {
 	client.HistoryClient
 	client.StatusClient
 	client.MempoolClient
+	client.TxClient
 	service.Service
 }
 

tm2/pkg/bft/rpc/client/rpc_test.go

@@ -366,10 +366,7 @@ func TestNumUnconfirmedTxs(t *testing.T) {
 	mempool.Flush()
 }
 
-/*
 func TestTx(t *testing.T) {
-	t.Parallel()
-
 	// first we broadcast a tx
 	c := getHTTPClient()
 	_, _, tx := MakeTxKV()
@@ -384,24 +381,21 @@ func TestTx(t *testing.T) {
 	cases := []struct {
 		valid bool
 		hash  []byte
-		prove bool
 	}{
 		// only valid if correct hash provided
-		{true, txHash, false},
-		{true, txHash, true},
-		{false, anotherTxHash, false},
-		{false, anotherTxHash, true},
-		{false, nil, false},
-		{false, nil, true},
+		{true, txHash},
+		{true, txHash},
+		{false, anotherTxHash},
+		{false, anotherTxHash},
+		{false, nil},
+		{false, nil},
 	}
 
-	for i, c := range GetClients() {
-		for j, tc := range cases {
-			t.Logf("client %d, case %d", i, j)
-
+	for _, c := range GetClients() {
+		for _, tc := range cases {
 			// now we query for the tx.
 			// since there's only one tx, we know index=0.
-			ptx, err := c.Tx(tc.hash, tc.prove)
+			ptx, err := c.Tx(tc.hash)
 
 			if !tc.valid {
 				require.NotNil(t, err)
@@ -412,17 +406,12 @@ func TestTx(t *testing.T) {
 				assert.Zero(t, ptx.Index)
 				assert.True(t, ptx.TxResult.IsOK())
 				assert.EqualValues(t, txHash, ptx.Hash)
-
-				// time to verify the proof
-				proof := ptx.Proof
-				if tc.prove && assert.EqualValues(t, tx, proof.Data) {
-					assert.NoError(t, proof.Proof.Verify(proof.RootHash, txHash))
-				}
 			}
 		}
 	}
 }
 
+/*
 func TestTxSearch(t *testing.T) {
 	t.Parallel()
 

tm2/pkg/bft/rpc/core/routes.go

@@ -8,16 +8,15 @@ import (
 // NOTE: Amino is registered in rpc/core/types/codec.go.
 var Routes = map[string]*rpc.RPCFunc{
 	// info API
-	"health":        rpc.NewRPCFunc(Health, ""),
-	"status":        rpc.NewRPCFunc(Status, ""),
-	"net_info":      rpc.NewRPCFunc(NetInfo, ""),
-	"blockchain":    rpc.NewRPCFunc(BlockchainInfo, "minHeight,maxHeight"),
-	"genesis":       rpc.NewRPCFunc(Genesis, ""),
-	"block":         rpc.NewRPCFunc(Block, "height"),
-	"block_results": rpc.NewRPCFunc(BlockResults, "height"),
-	"commit":        rpc.NewRPCFunc(Commit, "height"),
-	//"tx":                   rpc.NewRPCFunc(Tx, "hash,prove"),
-	//"tx_search":            rpc.NewRPCFunc(TxSearch, "query,prove,page,per_page"),
+	"health":               rpc.NewRPCFunc(Health, ""),
+	"status":               rpc.NewRPCFunc(Status, ""),
+	"net_info":             rpc.NewRPCFunc(NetInfo, ""),
+	"blockchain":           rpc.NewRPCFunc(BlockchainInfo, "minHeight,maxHeight"),
+	"genesis":              rpc.NewRPCFunc(Genesis, ""),
+	"block":                rpc.NewRPCFunc(Block, "height"),
+	"block_results":        rpc.NewRPCFunc(BlockResults, "height"),
+	"commit":               rpc.NewRPCFunc(Commit, "height"),
+	"tx":                   rpc.NewRPCFunc(Tx, "hash"),
 	"validators":           rpc.NewRPCFunc(Validators, "height"),
 	"dump_consensus_state": rpc.NewRPCFunc(DumpConsensusState, ""),
 	"consensus_state":      rpc.NewRPCFunc(ConsensusState, ""),