Add ability to remove "Parent" transactions from the mempool (#582)

* add the new transaction wrapper

* export and move DecodeChildTx

* return a more precise type (Tx instead of []byte) for DecodeChildTx

* add test and helper function

* linter

Author: evan-forbes

buf.yaml

@@ -1,3 +1,5 @@
+version: v1beta1
+
 build:
   roots:
     - proto

mempool/clist_mempool.go

@@ -605,6 +605,12 @@ func (mem *CListMempool) Update(
 		// https://github.com/tendermint/tendermint/issues/3322.
 		if e, ok := mem.txsMap.Load(TxKey(tx)); ok {
 			mem.removeTx(tx, e.(*clist.CElement), false)
+			// see if the transaction is a child transaction of a some parent
+			// transaction that exists in the mempool
+		} else if parentHash, _, isChild := types.DecodeChildTx(tx); isChild {
+			var parentKey [TxKeySize]byte
+			copy(parentKey[:], parentHash)
+			mem.RemoveTxByKey(parentKey, false)
 		}
 	}
 

mempool/clist_mempool_test.go

@@ -214,6 +214,29 @@ func TestMempoolUpdate(t *testing.T) {
 		err = mempool.CheckTx([]byte{0x03}, nil, TxInfo{})
 		require.NoError(t, err)
 	}
+
+	// 4. Removes a parent transaction after receiving a child transaction in the update
+	{
+		mempool.Flush()
+		parentTx := []byte{1, 2, 3, 4}
+		childTx := []byte{1, 2}
+		parentHash := sha256.Sum256(parentTx)
+
+		// create the wrapped child transaction
+		wTx, err := types.WrapChildTx(parentHash[:], childTx)
+		require.NoError(t, err)
+
+		// add the parent transaction to the mempool
+		err = mempool.CheckTx(parentTx, nil, TxInfo{})
+		require.NoError(t, err)
+
+		// remove the parent from the mempool using the wrapped child tx
+		err = mempool.Update(1, []types.Tx{wTx}, abciResponses(1, abci.CodeTypeOK), nil, nil)
+		require.NoError(t, err)
+
+		assert.Zero(t, mempool.Size())
+
+	}
 }
 
 func TestMempool_KeepInvalidTxsInCache(t *testing.T) {

proto/tendermint/types/types.pb.go

@@ -219,3 +219,10 @@ message TxProof {
   bytes                   data      = 2;
   tendermint.crypto.Proof proof     = 3;
 }
+
+// ChildTx wraps a transaction that was derived from a parent transaction. This
+// allows for removal of the parent transaction from the mempool.
+message ChildTx {
+  bytes parent_tx_hash = 1;
+  bytes tx = 2;
+}

proto/tendermint/types/types.proto

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/gogo/protobuf/proto"
 	"github.com/tendermint/tendermint/crypto/merkle"
 	"github.com/tendermint/tendermint/crypto/tmhash"
 	tmbytes "github.com/tendermint/tendermint/libs/bytes"
@@ -159,3 +160,29 @@ func ComputeProtoSizeForTxs(txs []Tx) int64 {
 	pdData := data.ToProto()
 	return int64(pdData.Size())
 }
+
+// DecodeChildTx attempts to unmarshal the provided transaction into a child
+// transaction wrapper, if this an be done, then it returns true. A child
+// transaction is a normal transaction that has been derived from a different
+// parent transaction. The returned hash is that of the parent transaction,
+// which allows us to remove the parent transaction from the mempool
+func DecodeChildTx(tx Tx) (hash []byte, unwrapped Tx, has bool) {
+	// attempt to unmarshal into a a child transaction
+	var childTx tmproto.ChildTx
+	err := proto.Unmarshal(tx, &childTx)
+	if err != nil {
+		return nil, nil, false
+	}
+	return childTx.ParentTxHash, childTx.Tx, true
+}
+
+// WrapChildTx creates a wrapped Tx that includes the parent transaction's hash
+// so that it can be easily removed from the mempool. note: must be unwrapped to
+// be a viable sdk.Tx
+func WrapChildTx(parentHash []byte, child Tx) (Tx, error) {
+	wTx := tmproto.ChildTx{
+		ParentTxHash: parentHash,
+		Tx:           child,
+	}
+	return proto.Marshal(&wTx)
+}