Index malleated transactions properly

proto/tendermint/abci/types.proto

@@ -338,6 +338,7 @@ message TxResult {
   uint32            index  = 2;
   bytes             tx     = 3;
   ResponseDeliverTx result = 4 [(gogoproto.nullable) = false];
+  bytes original_hash = 5;
 }
 
 //----------------------------------------

state/execution.go

@@ -548,11 +548,22 @@ func fireEvents(
 	}
 
 	for i, tx := range block.Data.Txs {
+		var txHash []byte
+		var rawTx []byte
+		if originalHash, malleatedTx, ismalleated := types.UnwrapMalleatedTx(tx); ismalleated {
+			txHash = originalHash
+			rawTx = malleatedTx
+		} else {
+			txHash = tx.Hash()
+			rawTx = tx
+		}
+
 		if err := eventBus.PublishEventTx(types.EventDataTx{TxResult: abci.TxResult{
-			Height: block.Height,
-			Index:  uint32(i),
-			Tx:     tx,
-			Result: *(abciResponses.DeliverTxs[i]),
+			Height:       block.Height,
+			Index:        uint32(i),
+			Tx:           rawTx,
+			Result:       *(abciResponses.DeliverTxs[i]),
+			OriginalHash: txHash,
 		}}); err != nil {
 			logger.Error("failed publishing event TX", "err", err)
 		}

state/txindex/kv/kv.go

@@ -12,6 +12,7 @@ import (
 	dbm "github.com/tendermint/tm-db"
 
 	abci "github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 	"github.com/tendermint/tendermint/libs/pubsub/query"
 	"github.com/tendermint/tendermint/state/indexer"
 	"github.com/tendermint/tendermint/state/txindex"
@@ -69,26 +70,7 @@ func (txi *TxIndex) AddBatch(b *txindex.Batch) error {
 	defer storeBatch.Close()
 
 	for _, result := range b.Ops {
-		hash := types.Tx(result.Tx).Hash()
-
-		// index tx by events
-		err := txi.indexEvents(result, hash, storeBatch)
-		if err != nil {
-			return err
-		}
-
-		// index by height (always)
-		err = storeBatch.Set(keyForHeight(result), hash)
-		if err != nil {
-			return err
-		}
-
-		rawBytes, err := proto.Marshal(result)
-		if err != nil {
-			return err
-		}
-		// index by hash (always)
-		err = storeBatch.Set(hash, rawBytes)
+		err := txi.indexResult(storeBatch, result)
 		if err != nil {
 			return err
 		}
@@ -105,26 +87,7 @@ func (txi *TxIndex) Index(result *abci.TxResult) error {
 	b := txi.store.NewBatch()
 	defer b.Close()
 
-	hash := types.Tx(result.Tx).Hash()
-
-	// index tx by events
-	err := txi.indexEvents(result, hash, b)
-	if err != nil {
-		return err
-	}
-
-	// index by height (always)
-	err = b.Set(keyForHeight(result), hash)
-	if err != nil {
-		return err
-	}
-
-	rawBytes, err := proto.Marshal(result)
-	if err != nil {
-		return err
-	}
-	// index by hash (always)
-	err = b.Set(hash, rawBytes)
+	err := txi.indexResult(b, result)
 	if err != nil {
 		return err
 	}
@@ -158,6 +121,39 @@ func (txi *TxIndex) indexEvents(result *abci.TxResult, hash []byte, store dbm.Ba
 	return nil
 }
 
+func (txi *TxIndex) indexResult(batch dbm.Batch, result *abci.TxResult) error {
+	var hash []byte
+	if len(result.OriginalHash) == tmhash.Size {
+		hash = result.OriginalHash
+	} else {
+		hash = types.Tx(result.Tx).Hash()
+	}
+
+	rawBytes, err := proto.Marshal(result)
+	if err != nil {
+		return err
+	}
+
+	// index tx by events
+	err = txi.indexEvents(result, hash, batch)
+	if err != nil {
+		return err
+	}
+
+	// index by height (always)
+	err = batch.Set(keyForHeight(result), hash)
+	if err != nil {
+		return err
+	}
+
+	// index by hash (always)
+	err = batch.Set(hash, rawBytes)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 // Search performs a search using the given query.
 //
 // It breaks the query into conditions (like "tx.height > 5"). For each

state/txindex/kv/kv_test.go

@@ -66,6 +66,51 @@ func TestTxIndex(t *testing.T) {
 	assert.True(t, proto.Equal(txResult2, loadedTxResult2))
 }
 
+func TestMalleatedTxIndex(t *testing.T) {
+	type test struct {
+		tx           types.Tx
+		originalHash []byte
+		expectedTx   []byte
+	}
+	originalTx1 := types.Tx([]byte("ORIGINAL_TX"))
+	malleatedTx1 := types.Tx([]byte("MALLEATED_TX"))
+
+	tests := []test{
+		// we expect to get the malleated tx returned when searching using the original hash
+		{
+			tx:           malleatedTx1,
+			originalHash: originalTx1.Hash(),
+			expectedTx:   malleatedTx1,
+		},
+	}
+
+	indexer := NewTxIndex(db.NewMemDB())
+
+	for i, tt := range tests {
+
+		txResult := &abci.TxResult{
+			Height: int64(i),
+			Index:  0,
+			Tx:     tt.tx,
+			Result: abci.ResponseDeliverTx{
+				Data: []byte{0},
+				Code: abci.CodeTypeOK, Log: "", Events: nil,
+			},
+			OriginalHash: tt.originalHash,
+		}
+		batch := txindex.NewBatch(1)
+		if err := batch.Add(txResult); err != nil {
+			t.Error(err)
+		}
+		err := indexer.AddBatch(batch)
+		require.NoError(t, err)
+
+		loadedTxResult, err := indexer.Get(tt.originalHash)
+		require.NoError(t, err)
+		assert.Equal(t, tt.expectedTx, loadedTxResult.Tx)
+	}
+}
+
 func TestTxSearch(t *testing.T) {
 	indexer := NewTxIndex(db.NewMemDB())
 

types/event_bus.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 
 	"github.com/tendermint/tendermint/abci/types"
+	"github.com/tendermint/tendermint/crypto/tmhash"
 	"github.com/tendermint/tendermint/libs/log"
 	tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
 	"github.com/tendermint/tendermint/libs/service"
@@ -178,9 +179,8 @@ func (b *EventBus) PublishEventTx(data EventDataTx) error {
 	ctx := context.Background()
 
 	var txHash []byte
-	if originalHash, malleated, ismalleated := UnwrapMalleatedTx(data.Tx); ismalleated {
-		txHash = originalHash
-		data.Tx = malleated
+	if len(data.OriginalHash) == tmhash.Size {
+		txHash = data.OriginalHash
 	} else {
 		txHash = Tx(data.Tx).Hash()
 	}

types/event_bus_test.go

@@ -77,8 +77,6 @@ func TestEventBusPublishEventMalleatedTx(t *testing.T) {
 
 	tx := Tx("foo")
 	malleatedTx := Tx("foo-malleated")
-	wrappedMalleatedTx, err := WrapMalleatedTx(tx.Hash(), malleatedTx)
-	require.NoError(t, err)
 
 	result := abci.ResponseDeliverTx{
 		Data: []byte("bar"),
@@ -104,10 +102,11 @@ func TestEventBusPublishEventMalleatedTx(t *testing.T) {
 	}()
 
 	err = eventBus.PublishEventTx(EventDataTx{abci.TxResult{
-		Height: 1,
-		Index:  0,
-		Tx:     wrappedMalleatedTx,
-		Result: result,
+		Height:       1,
+		Index:        0,
+		Tx:           malleatedTx,
+		Result:       result,
+		OriginalHash: tx.Hash(),
 	}})
 	assert.NoError(t, err)