expose /tx?hash="XXXXXXXXXXXX" RPC call

rpc/core/mempool.go

@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"time"
 
+	abci "github.com/tendermint/abci/types"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
 	"github.com/tendermint/tendermint/types"
-	abci "github.com/tendermint/abci/types"
 )
 
 //-----------------------------------------------------------------------------
@@ -65,7 +65,7 @@ func BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
 	if checkTxR.Code != abci.CodeType_OK {
 		// CheckTx failed!
 		return &ctypes.ResultBroadcastTxCommit{
-			CheckTx:  checkTxR,
+			CheckTx:   checkTxR,
 			DeliverTx: nil,
 		}, nil
 	}
@@ -84,13 +84,13 @@ func BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
 		}
 		log.Notice("DeliverTx passed ", "tx", []byte(tx), "response", deliverTxR)
 		return &ctypes.ResultBroadcastTxCommit{
-			CheckTx:  checkTxR,
+			CheckTx:   checkTxR,
 			DeliverTx: deliverTxR,
 		}, nil
 	case <-timer.C:
 		log.Error("failed to include tx")
 		return &ctypes.ResultBroadcastTxCommit{
-			CheckTx:  checkTxR,
+			CheckTx:   checkTxR,
 			DeliverTx: nil,
 		}, fmt.Errorf("Timed out waiting for transaction to be included in a block")
 	}

rpc/core/pipe.go

@@ -2,11 +2,12 @@ package core
 
 import (
 	cfg "github.com/tendermint/go-config"
-	"github.com/tendermint/go-crypto"
-	"github.com/tendermint/go-p2p"
 
+	crypto "github.com/tendermint/go-crypto"
+	p2p "github.com/tendermint/go-p2p"
 	"github.com/tendermint/tendermint/consensus"
 	"github.com/tendermint/tendermint/proxy"
+	"github.com/tendermint/tendermint/state/tx"
 	"github.com/tendermint/tendermint/types"
 )
 
@@ -42,9 +43,10 @@ var (
 	p2pSwitch      P2P
 
 	// objects
-	pubKey   crypto.PubKey
-	genDoc   *types.GenesisDoc // cache the genesis structure
-	addrBook *p2p.AddrBook
+	pubKey    crypto.PubKey
+	genDoc    *types.GenesisDoc // cache the genesis structure
+	addrBook  *p2p.AddrBook
+	txIndexer tx.Indexer
 )
 
 func SetConfig(c cfg.Config) {
@@ -86,3 +88,7 @@ func SetAddrBook(book *p2p.AddrBook) {
 func SetProxyAppQuery(appConn proxy.AppConnQuery) {
 	proxyAppQuery = appConn
 }
+
+func SetTxIndexer(indexer tx.Indexer) {
+	txIndexer = indexer
+}

rpc/core/routes.go

@@ -1,9 +1,12 @@
 package core
 
 import (
+	"strings"
+
 	rpc "github.com/tendermint/go-rpc/server"
 	"github.com/tendermint/go-rpc/types"
 	ctypes "github.com/tendermint/tendermint/rpc/core/types"
+	"github.com/tendermint/tendermint/types"
 )
 
 // TODO: better system than "unsafe" prefix
@@ -23,6 +26,7 @@ var Routes = map[string]*rpc.RPCFunc{
 	"dump_consensus_state": rpc.NewRPCFunc(DumpConsensusStateResult, ""),
 	"unconfirmed_txs":      rpc.NewRPCFunc(UnconfirmedTxsResult, ""),
 	"num_unconfirmed_txs":  rpc.NewRPCFunc(NumUnconfirmedTxsResult, ""),
+	"tx": rpc.NewRPCFunc(Tx, "hash"),
 
 	// broadcast API
 	"broadcast_tx_commit": rpc.NewRPCFunc(BroadcastTxCommitResult, "tx"),
@@ -45,185 +49,105 @@ var Routes = map[string]*rpc.RPCFunc{
 }
 
 func SubscribeResult(wsCtx rpctypes.WSRPCContext, event string) (ctypes.TMResult, error) {
-	if r, err := Subscribe(wsCtx, event); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return Subscribe(wsCtx, event)
 }
 
 func UnsubscribeResult(wsCtx rpctypes.WSRPCContext, event string) (ctypes.TMResult, error) {
-	if r, err := Unsubscribe(wsCtx, event); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return Unsubscribe(wsCtx, event)
 }
 
 func StatusResult() (ctypes.TMResult, error) {
-	if r, err := Status(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return Status()
 }
 
 func NetInfoResult() (ctypes.TMResult, error) {
-	if r, err := NetInfo(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return NetInfo()
 }
 
 func UnsafeDialSeedsResult(seeds []string) (ctypes.TMResult, error) {
-	if r, err := UnsafeDialSeeds(seeds); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return UnsafeDialSeeds(seeds)
 }
 
 func BlockchainInfoResult(min, max int) (ctypes.TMResult, error) {
-	if r, err := BlockchainInfo(min, max); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return BlockchainInfo(min, max)
 }
 
 func GenesisResult() (ctypes.TMResult, error) {
-	if r, err := Genesis(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return Genesis()
 }
 
 func BlockResult(height int) (ctypes.TMResult, error) {
-	if r, err := Block(height); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return Block(height)
 }
 
 func CommitResult(height int) (ctypes.TMResult, error) {
-	if r, err := Commit(height); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return Commit(height)
 }
 
 func ValidatorsResult() (ctypes.TMResult, error) {
-	if r, err := Validators(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return Validators()
 }
 
 func DumpConsensusStateResult() (ctypes.TMResult, error) {
-	if r, err := DumpConsensusState(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return DumpConsensusState()
 }
 
 func UnconfirmedTxsResult() (ctypes.TMResult, error) {
-	if r, err := UnconfirmedTxs(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return UnconfirmedTxs()
 }
 
 func NumUnconfirmedTxsResult() (ctypes.TMResult, error) {
-	if r, err := NumUnconfirmedTxs(); err != nil {
+	return NumUnconfirmedTxs()
+}
+
+// Tx allow user to query the transaction results. `nil` could mean the
+// transaction is in the mempool, invalidated, or was not send in the first
+// place.
+func Tx(hash string) (ctypes.TMResult, error) {
+	r, err := txIndexer.Tx(strings.ToLower(hash))
+	// nil-pointer interface values are forbidden in go-rpc
+	if r == (*types.TxResult)(nil) {
 		return nil, err
-	} else {
-		return r, nil
 	}
+	return r, err
 }
 
 func BroadcastTxCommitResult(tx []byte) (ctypes.TMResult, error) {
-	if r, err := BroadcastTxCommit(tx); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return BroadcastTxCommit(tx)
 }
 
 func BroadcastTxSyncResult(tx []byte) (ctypes.TMResult, error) {
-	if r, err := BroadcastTxSync(tx); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return BroadcastTxSync(tx)
 }
 
 func BroadcastTxAsyncResult(tx []byte) (ctypes.TMResult, error) {
-	if r, err := BroadcastTxAsync(tx); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return BroadcastTxAsync(tx)
 }
 
 func ABCIQueryResult(path string, data []byte, prove bool) (ctypes.TMResult, error) {
-	if r, err := ABCIQuery(path, data, prove); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return ABCIQuery(path, data, prove)
 }
 
 func ABCIInfoResult() (ctypes.TMResult, error) {
-	if r, err := ABCIInfo(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return ABCIInfo()
 }
 
 func UnsafeFlushMempoolResult() (ctypes.TMResult, error) {
-	if r, err := UnsafeFlushMempool(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return UnsafeFlushMempool()
 }
 
 func UnsafeSetConfigResult(typ, key, value string) (ctypes.TMResult, error) {
-	if r, err := UnsafeSetConfig(typ, key, value); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return UnsafeSetConfig(typ, key, value)
 }
 
 func UnsafeStartCPUProfilerResult(filename string) (ctypes.TMResult, error) {
-	if r, err := UnsafeStartCPUProfiler(filename); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return UnsafeStartCPUProfiler(filename)
 }
 
 func UnsafeStopCPUProfilerResult() (ctypes.TMResult, error) {
-	if r, err := UnsafeStopCPUProfiler(); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return UnsafeStopCPUProfiler()
 }
 
 func UnsafeWriteHeapProfileResult(filename string) (ctypes.TMResult, error) {
-	if r, err := UnsafeWriteHeapProfile(filename); err != nil {
-		return nil, err
-	} else {
-		return r, nil
-	}
+	return UnsafeWriteHeapProfile(filename)
 }

rpc/core/types/responses.go

@@ -127,6 +127,7 @@ const (
 	ResultTypeBroadcastTx       = byte(0x60)
 	ResultTypeUnconfirmedTxs    = byte(0x61)
 	ResultTypeBroadcastTxCommit = byte(0x62)
+	ResultTypeTx                = byte(0x63)
 
 	// 0x7 bytes are for querying the application
 	ResultTypeABCIQuery = byte(0x70)
@@ -163,6 +164,7 @@ var _ = wire.RegisterInterface(
 	wire.ConcreteType{&ResultDumpConsensusState{}, ResultTypeDumpConsensusState},
 	wire.ConcreteType{&ResultBroadcastTx{}, ResultTypeBroadcastTx},
 	wire.ConcreteType{&ResultBroadcastTxCommit{}, ResultTypeBroadcastTxCommit},
+	wire.ConcreteType{&types.TxResult{}, ResultTypeTx},
 	wire.ConcreteType{&ResultUnconfirmedTxs{}, ResultTypeUnconfirmedTxs},
 	wire.ConcreteType{&ResultSubscribe{}, ResultTypeSubscribe},
 	wire.ConcreteType{&ResultUnsubscribe{}, ResultTypeUnsubscribe},