update for new abci int types

consensus/common_test.go

@@ -59,7 +59,7 @@ type validatorStub struct {
 	types.PrivValidator
 }
 
-var testMinPower = 10
+var testMinPower int64 = 10
 
 func NewValidatorStub(privValidator types.PrivValidator, valIndex int) *validatorStub {
 	return &validatorStub{
@@ -372,7 +372,7 @@ func randConsensusNet(nValidators int, testName string, tickerFunc func() Timeou
 
 // nPeers = nValidators + nNotValidator
 func randConsensusNetWithPeers(nValidators, nPeers int, testName string, tickerFunc func() TimeoutTicker, appFunc func() abci.Application) []*ConsensusState {
-	genDoc, privVals := randGenesisDoc(nValidators, false, int64(testMinPower))
+	genDoc, privVals := randGenesisDoc(nValidators, false, testMinPower)
 	css := make([]*ConsensusState, nPeers)
 	logger := consensusLogger()
 	for i := 0; i < nPeers; i++ {

consensus/mempool_test.go

@@ -8,9 +8,11 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
+	"github.com/tendermint/abci/example/code"
 	abci "github.com/tendermint/abci/types"
-	"github.com/tendermint/tendermint/types"
 	cmn "github.com/tendermint/tmlibs/common"
+
+	"github.com/tendermint/tendermint/types"
 )
 
 func init() {
@@ -135,7 +137,7 @@ func TestRmBadTx(t *testing.T) {
 		// CheckTx should not err, but the app should return a bad abci code
 		// and the tx should get removed from the pool
 		err := cs.mempool.CheckTx(txBytes, func(r *abci.Response) {
-			if r.GetCheckTx().Code != abci.CodeType_BadNonce {
+			if r.GetCheckTx().Code != code.CodeTypeBadNonce {
 				t.Fatalf("expected checktx to return bad nonce, got %v", r)
 			}
 			checkTxRespCh <- struct{}{}
@@ -193,22 +195,22 @@ func (app *CounterApplication) DeliverTx(tx []byte) abci.ResponseDeliverTx {
 	txValue := txAsUint64(tx)
 	if txValue != uint64(app.txCount) {
 		return abci.ResponseDeliverTx{
-			Code: abci.CodeType_BadNonce,
+			Code: code.CodeTypeBadNonce,
 			Log:  fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue)}
 	}
 	app.txCount += 1
-	return abci.ResponseDeliverTx{Code: abci.CodeType_OK}
+	return abci.ResponseDeliverTx{Code: code.CodeTypeOK}
 }
 
 func (app *CounterApplication) CheckTx(tx []byte) abci.ResponseCheckTx {
 	txValue := txAsUint64(tx)
 	if txValue != uint64(app.mempoolTxCount) {
 		return abci.ResponseCheckTx{
-			Code: abci.CodeType_BadNonce,
+			Code: code.CodeTypeBadNonce,
 			Log:  fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.mempoolTxCount, txValue)}
 	}
 	app.mempoolTxCount += 1
-	return abci.ResponseCheckTx{Code: abci.CodeType_OK}
+	return abci.ResponseCheckTx{Code: code.CodeTypeOK}
 }
 
 func txAsUint64(tx []byte) uint64 {
@@ -220,10 +222,10 @@ func txAsUint64(tx []byte) uint64 {
 func (app *CounterApplication) Commit() abci.ResponseCommit {
 	app.mempoolTxCount = app.txCount
 	if app.txCount == 0 {
-		return abci.ResponseCommit{Code: abci.CodeType_OK}
+		return abci.ResponseCommit{Code: code.CodeTypeOK}
 	} else {
 		hash := make([]byte, 8)
 		binary.BigEndian.PutUint64(hash, uint64(app.txCount))
-		return abci.ResponseCommit{Code: abci.CodeType_OK, Data: hash}
+		return abci.ResponseCommit{Code: code.CodeTypeOK, Data: hash}
 	}
 }

consensus/reactor_test.go

@@ -209,7 +209,7 @@ func TestValidatorSetChanges(t *testing.T) {
 	t.Log("---------------------------- Testing adding one validator")
 
 	newValidatorPubKey1 := css[nVals].privValidator.GetPubKey()
-	newValidatorTx1 := dummy.MakeValSetChangeTx(newValidatorPubKey1.Bytes(), uint64(testMinPower))
+	newValidatorTx1 := dummy.MakeValSetChangeTx(newValidatorPubKey1.Bytes(), testMinPower)
 
 	// wait till everyone makes block 2
 	// ensure the commit includes all validators
@@ -251,10 +251,10 @@ func TestValidatorSetChanges(t *testing.T) {
 	t.Log("---------------------------- Testing adding two validators at once")
 
 	newValidatorPubKey2 := css[nVals+1].privValidator.GetPubKey()
-	newValidatorTx2 := dummy.MakeValSetChangeTx(newValidatorPubKey2.Bytes(), uint64(testMinPower))
+	newValidatorTx2 := dummy.MakeValSetChangeTx(newValidatorPubKey2.Bytes(), testMinPower)
 
 	newValidatorPubKey3 := css[nVals+2].privValidator.GetPubKey()
-	newValidatorTx3 := dummy.MakeValSetChangeTx(newValidatorPubKey3.Bytes(), uint64(testMinPower))
+	newValidatorTx3 := dummy.MakeValSetChangeTx(newValidatorPubKey3.Bytes(), testMinPower)
 
 	waitForAndValidateBlock(t, nPeers, activeVals, eventChans, css, newValidatorTx2, newValidatorTx3)
 	waitForAndValidateBlock(t, nPeers, activeVals, eventChans, css)

consensus/replay.go

@@ -401,5 +401,5 @@ func (mock *mockProxyApp) EndBlock(req abci.RequestEndBlock) abci.ResponseEndBlo
 }
 
 func (mock *mockProxyApp) Commit() abci.ResponseCommit {
-	return abci.ResponseCommit{Code: abci.CodeType_OK, Data: mock.appHash}
+	return abci.ResponseCommit{Code: abci.CodeTypeOK, Data: mock.appHash}
 }

mempool/mempool_test.go

@@ -14,12 +14,14 @@ import (
 	"github.com/tendermint/abci/example/counter"
 	"github.com/tendermint/abci/example/dummy"
 	abci "github.com/tendermint/abci/types"
+	cmn "github.com/tendermint/tmlibs/common"
 	"github.com/tendermint/tmlibs/log"
 
 	cfg "github.com/tendermint/tendermint/config"
 	"github.com/tendermint/tendermint/proxy"
 	"github.com/tendermint/tendermint/types"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -122,10 +124,10 @@ func TestSerialReap(t *testing.T) {
 	mempool := newMempoolWithApp(cc)
 	appConnCon, _ := cc.NewABCIClient()
 	appConnCon.SetLogger(log.TestingLogger().With("module", "abci-client", "connection", "consensus"))
-	if err := appConnCon.Start(); err != nil {
-		t.Fatalf("Error starting ABCI client: %v", err.Error())
-	}
+	err := appConnCon.Start()
+	assert.Nil(t, err)
 
+	cacheMap := make(map[string]struct{})
 	deliverTxsRange := func(start, end int) {
 		// Deliver some txs.
 		for i := start; i < end; i++ {
@@ -134,26 +136,23 @@ func TestSerialReap(t *testing.T) {
 			txBytes := make([]byte, 8)
 			binary.BigEndian.PutUint64(txBytes, uint64(i))
 			err := mempool.CheckTx(txBytes, nil)
-			if err != nil {
-				t.Fatalf("Error after CheckTx: %v", err)
+			_, cached := cacheMap[string(txBytes)]
+			if cached {
+				assert.NotNil(t, err, "expected error for cached tx")
+			} else {
+				assert.Nil(t, err, "expected no err for uncached tx")
 			}
+			cacheMap[string(txBytes)] = struct{}{}
 
-			// This will fail because not serial (incrementing)
-			// However, error should still be nil.
-			// It just won't show up on Reap().
+			// Duplicates are cached and should return error
 			err = mempool.CheckTx(txBytes, nil)
-			if err != nil {
-				t.Fatalf("Error after CheckTx: %v", err)
-			}
-
+			assert.NotNil(t, err, "Expected error after CheckTx on duplicated tx")
 		}
 	}
 
 	reapCheck := func(exp int) {
 		txs := mempool.Reap(-1)
-		if len(txs) != exp {
-			t.Fatalf("Expected to reap %v txs but got %v", exp, len(txs))
-		}
+		assert.Equal(t, len(txs), exp, cmn.Fmt("Expected to reap %v txs but got %v", exp, len(txs)))
 	}
 
 	updateRange := func(start, end int) {

node/node.go

@@ -256,20 +256,20 @@ func NewNode(config *cfg.Config,
 			if err != nil {
 				return err
 			}
-			if resQuery.Code.IsOK() {
-				return nil
+			if resQuery.IsErr() {
+				return resQuery
 			}
-			return errors.New(resQuery.Code.String())
+			return nil
 		})
 		sw.SetPubKeyFilter(func(pubkey crypto.PubKeyEd25519) error {
 			resQuery, err := proxyApp.Query().QuerySync(abci.RequestQuery{Path: cmn.Fmt("/p2p/filter/pubkey/%X", pubkey.Bytes())})
 			if err != nil {
 				return err
 			}
-			if resQuery.Code.IsOK() {
-				return nil
+			if resQuery.IsErr() {
+				return resQuery
 			}
-			return errors.New(resQuery.Code.String())
+			return nil
 		})
 	}
 

rpc/client/event_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	abci "github.com/tendermint/abci/types"
 	cmn "github.com/tendermint/tmlibs/common"
 
 	"github.com/tendermint/tendermint/rpc/client"
@@ -90,7 +91,7 @@ func TestTxEventsSentWithBroadcastTxAsync(t *testing.T) {
 		// send async
 		txres, err := c.BroadcastTxAsync(tx)
 		require.Nil(err, "%+v", err)
-		require.True(txres.Code.IsOK())
+		require.Equal(txres.Code, abci.CodeTypeOK) // FIXME
 
 		// and wait for confirmation
 		evt, err := client.WaitForOneEvent(c, evtTyp, waitForEventTimeout)
@@ -100,7 +101,7 @@ func TestTxEventsSentWithBroadcastTxAsync(t *testing.T) {
 		require.True(ok, "%d: %#v", i, evt)
 		// make sure this is the proper tx
 		require.EqualValues(tx, txe.Tx)
-		require.True(txe.Result.Code.IsOK())
+		require.True(txe.Result.IsOK())
 	}
 }
 
@@ -122,7 +123,7 @@ func TestTxEventsSentWithBroadcastTxSync(t *testing.T) {
 		// send sync
 		txres, err := c.BroadcastTxSync(tx)
 		require.Nil(err, "%+v", err)
-		require.True(txres.Code.IsOK())
+		require.Equal(txres.Code, abci.CodeTypeOK) // FIXME
 
 		// and wait for confirmation
 		evt, err := client.WaitForOneEvent(c, evtTyp, waitForEventTimeout)
@@ -132,6 +133,6 @@ func TestTxEventsSentWithBroadcastTxSync(t *testing.T) {
 		require.True(ok, "%d: %#v", i, evt)
 		// make sure this is the proper tx
 		require.EqualValues(tx, txe.Tx)
-		require.True(txe.Result.Code.IsOK())
+		require.True(txe.Result.IsOK())
 	}
 }

rpc/client/mock/abci.go

@@ -32,7 +32,7 @@ func (a ABCIApp) ABCIQuery(path string, data data.Bytes) (*ctypes.ResultABCIQuer
 
 func (a ABCIApp) ABCIQueryWithOptions(path string, data data.Bytes, opts client.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) {
 	q := a.App.Query(abci.RequestQuery{data, path, opts.Height, opts.Trusted})
-	return &ctypes.ResultABCIQuery{q.Result()}, nil
+	return &ctypes.ResultABCIQuery{&q}, nil
 }
 
 func (a ABCIApp) BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
@@ -91,7 +91,7 @@ func (m ABCIMock) ABCIQueryWithOptions(path string, data data.Bytes, opts client
 		return nil, err
 	}
 	resQuery := res.(abci.ResponseQuery)
-	return &ctypes.ResultABCIQuery{resQuery.Result()}, nil
+	return &ctypes.ResultABCIQuery{&resQuery}, nil
 }
 
 func (m ABCIMock) BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
@@ -135,7 +135,7 @@ func NewABCIRecorder(client client.ABCIClient) *ABCIRecorder {
 type QueryArgs struct {
 	Path    string
 	Data    data.Bytes
-	Height  uint64
+	Height  int64
 	Trusted bool
 }
 

rpc/client/mock/abci_test.go

@@ -22,7 +22,7 @@ func TestABCIMock(t *testing.T) {
 	assert, require := assert.New(t), require.New(t)
 
 	key, value := []byte("foo"), []byte("bar")
-	height := uint64(10)
+	height := int64(10)
 	goodTx := types.Tx{0x01, 0xff}
 	badTx := types.Tx{0x12, 0x21}
 
@@ -168,9 +168,9 @@ func TestABCIApp(t *testing.T) {
 	tx := fmt.Sprintf("%s=%s", key, value)
 	res, err := m.BroadcastTxCommit(types.Tx(tx))
 	require.Nil(err)
-	assert.True(res.CheckTx.Code.IsOK())
+	assert.True(res.CheckTx.IsOK())
 	require.NotNil(res.DeliverTx)
-	assert.True(res.DeliverTx.Code.IsOK())
+	assert.True(res.DeliverTx.IsOK())
 
 	// check the key
 	qres, err := m.ABCIQueryWithOptions("/key", data.Bytes(key), client.ABCIQueryOptions{Trusted: true})

rpc/client/rpc_test.go

@@ -8,7 +8,9 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	abci "github.com/tendermint/abci/types"
 	"github.com/tendermint/iavl"
+
 	"github.com/tendermint/tendermint/rpc/client"
 	rpctest "github.com/tendermint/tendermint/rpc/test"
 	"github.com/tendermint/tendermint/types"
@@ -110,7 +112,7 @@ func TestABCIQuery(t *testing.T) {
 		// wait before querying
 		client.WaitForHeight(c, apph, nil)
 		qres, err := c.ABCIQuery("/key", k)
-		if assert.Nil(t, err) && assert.True(t, qres.Code.IsOK()) {
+		if assert.Nil(t, err) && assert.True(t, qres.IsOK()) {
 			assert.EqualValues(t, v, qres.Value)
 		}
 	}
@@ -136,7 +138,7 @@ func TestAppCalls(t *testing.T) {
 		k, v, tx := MakeTxKV()
 		bres, err := c.BroadcastTxCommit(tx)
 		require.Nil(err, "%d: %+v", i, err)
-		require.True(bres.DeliverTx.Code.IsOK())
+		require.True(bres.DeliverTx.IsOK())
 		txh := bres.Height
 		apph := txh + 1 // this is where the tx will be applied to the state
 
@@ -145,7 +147,7 @@ func TestAppCalls(t *testing.T) {
 			t.Error(err)
 		}
 		qres, err := c.ABCIQueryWithOptions("/key", k, client.ABCIQueryOptions{Trusted: true})
-		if assert.Nil(err) && assert.True(qres.Code.IsOK()) {
+		if assert.Nil(err) && assert.True(qres.IsOK()) {
 			// assert.Equal(k, data.GetKey())  // only returned for proofs
 			assert.EqualValues(v, qres.Value)
 		}
@@ -193,7 +195,7 @@ func TestAppCalls(t *testing.T) {
 
 		// and we got a proof that works!
 		pres, err := c.ABCIQueryWithOptions("/key", k, client.ABCIQueryOptions{Trusted: false})
-		if assert.Nil(err) && assert.True(pres.Code.IsOK()) {
+		if assert.Nil(err) && assert.True(pres.IsOK()) {
 			proof, err := iavl.ReadKeyExistsProof(pres.Proof)
 			if assert.Nil(err) {
 				key := pres.Key
@@ -216,7 +218,7 @@ func TestBroadcastTxSync(t *testing.T) {
 		_, _, tx := MakeTxKV()
 		bres, err := c.BroadcastTxSync(tx)
 		require.Nil(err, "%d: %+v", i, err)
-		require.True(bres.Code.IsOK())
+		require.Equal(bres.Code, abci.CodeTypeOK) // FIXME
 
 		require.Equal(initMempoolSize+1, mempool.Size())
 
@@ -234,8 +236,8 @@ func TestBroadcastTxCommit(t *testing.T) {
 		_, _, tx := MakeTxKV()
 		bres, err := c.BroadcastTxCommit(tx)
 		require.Nil(err, "%d: %+v", i, err)
-		require.True(bres.CheckTx.Code.IsOK())
-		require.True(bres.DeliverTx.Code.IsOK())
+		require.True(bres.CheckTx.IsOK())
+		require.True(bres.DeliverTx.IsOK())
 
 		require.Equal(0, mempool.Size())
 	}
@@ -284,7 +286,7 @@ func TestTx(t *testing.T) {
 				assert.EqualValues(txHeight, ptx.Height)
 				assert.EqualValues(tx, ptx.Tx)
 				assert.Zero(ptx.Index)
-				assert.True(ptx.TxResult.Code.IsOK())
+				assert.True(ptx.TxResult.IsOK())
 
 				// time to verify the proof
 				proof := ptx.Proof
@@ -321,7 +323,7 @@ func TestTxSearch(t *testing.T) {
 		assert.EqualValues(t, txHeight, ptx.Height)
 		assert.EqualValues(t, tx, ptx.Tx)
 		assert.Zero(t, ptx.Index)
-		assert.True(t, ptx.TxResult.Code.IsOK())
+		assert.True(t, ptx.TxResult.IsOK())
 
 		// time to verify the proof
 		proof := ptx.Proof

rpc/client/types.go

@@ -3,7 +3,7 @@ package client
 // ABCIQueryOptions can be used to provide options for ABCIQuery call other
 // than the DefaultABCIQueryOptions.
 type ABCIQueryOptions struct {
-	Height  uint64
+	Height  int64
 	Trusted bool
 }
 

rpc/core/abci.go

@@ -45,9 +45,9 @@ import (
 // |-----------+--------+---------+----------+------------------------------------------------|
 // | path      | string | false   | false    | Path to the data ("/a/b/c")                    |
 // | data      | []byte | false   | true     | Data                                           |
-// | height    | uint64 | 0       | false    | Height (0 means latest)                        |
+// | height    | int64 | 0       | false    | Height (0 means latest)                        |
 // | trusted   | bool   | false   | false    | Does not include a proof of the data inclusion |
-func ABCIQuery(path string, data data.Bytes, height uint64, trusted bool) (*ctypes.ResultABCIQuery, error) {
+func ABCIQuery(path string, data data.Bytes, height int64, trusted bool) (*ctypes.ResultABCIQuery, error) {
 	resQuery, err := proxyAppQuery.QuerySync(abci.RequestQuery{
 		Path:   path,
 		Data:   data,
@@ -59,7 +59,7 @@ func ABCIQuery(path string, data data.Bytes, height uint64, trusted bool) (*ctyp
 	}
 	logger.Info("ABCIQuery", "path", path, "data", data, "result", resQuery)
 	return &ctypes.ResultABCIQuery{
-		resQuery.Result(),
+		resQuery,
 	}, nil
 }
 

rpc/core/mempool.go

@@ -174,7 +174,7 @@ func BroadcastTxCommit(tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
 	}
 	checkTxRes := <-checkTxResCh
 	checkTxR := checkTxRes.GetCheckTx()
-	if checkTxR.Code != abci.CodeType_OK {
+	if checkTxR.Code != abci.CodeTypeOK {
 		// CheckTx failed!
 		return &ctypes.ResultBroadcastTxCommit{
 			CheckTx:   *checkTxR,

rpc/core/types/responses.go

@@ -96,9 +96,9 @@ type ResultDumpConsensusState struct {
 }
 
 type ResultBroadcastTx struct {
-	Code abci.CodeType `json:"code"`
-	Data data.Bytes    `json:"data"`
-	Log  string        `json:"log"`
+	Code uint32     `json:"code"`
+	Data data.Bytes `json:"data"`
+	Log  string     `json:"log"`
 
 	Hash data.Bytes `json:"hash"`
 }
@@ -128,7 +128,7 @@ type ResultABCIInfo struct {
 }
 
 type ResultABCIQuery struct {
-	*abci.ResultQuery `json:"response"`
+	*abci.ResponseQuery `json:"response"`
 }
 
 type ResultUnsafeFlushMempool struct{}

state/execution.go

@@ -54,7 +54,7 @@ func execBlockOnProxyApp(txEventPublisher types.TxEventPublisher, proxyAppConn p
 			// Blocks may include invalid txs.
 			// reqDeliverTx := req.(abci.RequestDeliverTx)
 			txResult := r.DeliverTx
-			if txResult.Code == abci.CodeType_OK {
+			if txResult.Code == abci.CodeTypeOK {
 				validTxs++
 			} else {
 				logger.Debug("Invalid tx", "code", txResult.Code, "log", txResult.Log)
@@ -80,6 +80,8 @@ func execBlockOnProxyApp(txEventPublisher types.TxEventPublisher, proxyAppConn p
 	_, err := proxyAppConn.BeginBlockSync(abci.RequestBeginBlock{
 		block.Hash(),
 		types.TM2PB.Header(block.Header),
+		nil,
+		nil,
 	})
 	if err != nil {
 		logger.Error("Error in proxyAppConn.BeginBlock", "err", err)
@@ -95,7 +97,7 @@ func execBlockOnProxyApp(txEventPublisher types.TxEventPublisher, proxyAppConn p
 	}
 
 	// End block
-	abciResponses.EndBlock, err = proxyAppConn.EndBlockSync(abci.RequestEndBlock{uint64(block.Height)})
+	abciResponses.EndBlock, err = proxyAppConn.EndBlockSync(abci.RequestEndBlock{block.Height})
 	if err != nil {
 		logger.Error("Error in proxyAppConn.EndBlock", "err", err)
 		return nil, err

state/txindex/kv/kv.go

@@ -211,10 +211,10 @@ func lookForHash(conditions []query.Condition) (hash []byte, err error, ok bool)
 	return
 }
 
-func lookForHeight(conditions []query.Condition) (height uint64, index int) {
+func lookForHeight(conditions []query.Condition) (height int64, index int) {
 	for i, c := range conditions {
 		if c.Tag == types.TxHeightKey {
-			return uint64(c.Operand.(int64)), i
+			return c.Operand.(int64), i
 		}
 	}
 	return 0, -1
@@ -330,7 +330,7 @@ LOOP:
 ///////////////////////////////////////////////////////////////////////////////
 // Keys
 
-func startKey(c query.Condition, height uint64) []byte {
+func startKey(c query.Condition, height int64) []byte {
 	var key string
 	if height > 0 {
 		key = fmt.Sprintf("%s/%v/%d", c.Tag, c.Operand, height)
@@ -340,7 +340,7 @@ func startKey(c query.Condition, height uint64) []byte {
 	return []byte(key)
 }
 
-func startKeyForRange(r queryRange, height uint64) []byte {
+func startKeyForRange(r queryRange, height int64) []byte {
 	if r.lowerBound == nil {
 		return []byte(fmt.Sprintf("%s", r.key))
 	}

state/txindex/kv/kv_test.go

@@ -19,7 +19,7 @@ func TestTxIndex(t *testing.T) {
 	indexer := NewTxIndex(db.NewMemDB())
 
 	tx := types.Tx("HELLO WORLD")
-	txResult := &types.TxResult{1, 0, tx, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeType_OK, Log: "", Tags: []*abci.KVPair{}}}
+	txResult := &types.TxResult{1, 0, tx, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeTypeOK, Log: "", Tags: []*abci.KVPair{}}}
 	hash := tx.Hash()
 
 	batch := txindex.NewBatch(1)
@@ -34,7 +34,7 @@ func TestTxIndex(t *testing.T) {
 	assert.Equal(t, txResult, loadedTxResult)
 
 	tx2 := types.Tx("BYE BYE WORLD")
-	txResult2 := &types.TxResult{1, 0, tx2, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeType_OK, Log: "", Tags: []*abci.KVPair{}}}
+	txResult2 := &types.TxResult{1, 0, tx2, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeTypeOK, Log: "", Tags: []*abci.KVPair{}}}
 	hash2 := tx2.Hash()
 
 	err = indexer.Index(txResult2)
@@ -145,12 +145,12 @@ func TestIndexAllTags(t *testing.T) {
 
 func txResultWithTags(tags []*abci.KVPair) *types.TxResult {
 	tx := types.Tx("HELLO WORLD")
-	return &types.TxResult{1, 0, tx, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeType_OK, Log: "", Tags: tags}}
+	return &types.TxResult{1, 0, tx, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeTypeOK, Log: "", Tags: tags}}
 }
 
 func benchmarkTxIndex(txsCount int, b *testing.B) {
 	tx := types.Tx("HELLO WORLD")
-	txResult := &types.TxResult{1, 0, tx, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeType_OK, Log: "", Tags: []*abci.KVPair{}}}
+	txResult := &types.TxResult{1, 0, tx, abci.ResponseDeliverTx{Data: []byte{0}, Code: abci.CodeTypeOK, Log: "", Tags: []*abci.KVPair{}}}
 
 	dir, err := ioutil.TempDir("", "tx_index_db")
 	if err != nil {