feat: add tx status in mempool

consensus/replay_stubs.go

@@ -50,7 +50,7 @@ func (emptyMempool) TxsWaitChan() <-chan struct{} { return nil }
 func (emptyMempool) InitWAL() error                          { return nil }
 func (emptyMempool) CloseWAL()                               {}
 func (emptyMempool) GetTxByKey(types.TxKey) (types.Tx, bool) { return nil, false }
-func (emptyMempool) IsTxEvicted(types.TxKey) bool            { return false }
+func (emptyMempool) WasRecentlyEvicted(types.TxKey) bool     { return false }
 
 //-----------------------------------------------------------------------------
 // mockProxyApp uses ABCIResponses to give the right results.

mempool/cat/pool.go

@@ -94,7 +94,7 @@ func NewTxPool(
 		proxyAppConn:     proxyAppConn,
 		metrics:          mempool.NopMetrics(),
 		rejectedTxCache:  NewLRUTxCache(cfg.CacheSize),
-		evictedTxCache:   NewLRUTxCache(cfg.CacheSize),
+		evictedTxCache:   NewLRUTxCache(cfg.CacheSize / 5),
 		seenByPeersSet:   NewSeenTxSet(),
 		height:           height,
 		preCheckFn:       func(_ types.Tx) error { return nil },
@@ -190,9 +190,9 @@ func (txmp *TxPool) GetTxByKey(txKey types.TxKey) (types.Tx, bool) {
 	return types.Tx{}, false
 }
 
-// IsTxEvicted returns a bool indicating whether the transaction with
+// WasRecentlyEvicted returns a bool indicating whether the transaction with
 // the specified key was recently evicted and is currently within the cache.
-func (txmp *TxPool) IsTxEvicted(txKey types.TxKey) bool {
+func (txmp *TxPool) WasRecentlyEvicted(txKey types.TxKey) bool {
 	return txmp.evictedTxCache.Has(txKey)
 }
 
@@ -210,9 +210,13 @@ func (txmp *TxPool) CheckToPurgeExpiredTxs() {
 	defer txmp.updateMtx.Unlock()
 	if txmp.config.TTLDuration > 0 && time.Since(txmp.lastPurgeTime) > txmp.config.TTLDuration {
 		expirationAge := time.Now().Add(-txmp.config.TTLDuration)
-		// a height of 0 means no transactions will be removed because of height
+		// A height of 0 means no transactions will be removed because of height
 		// (in other words, no transaction has a height less than 0)
-		numExpired := txmp.store.purgeExpiredTxs(0, expirationAge, txmp.evictedTxCache)
+		purgedTxs, numExpired := txmp.store.purgeExpiredTxs(0, expirationAge)
+		// Add the purged transactions to the evicted cache
+		for _, tx := range purgedTxs {
+			txmp.evictedTxCache.Push(tx.key)
+		}
 		txmp.metrics.EvictedTxs.Add(float64(numExpired))
 		txmp.lastPurgeTime = time.Now()
 	}
@@ -738,7 +742,11 @@ func (txmp *TxPool) purgeExpiredTxs(blockHeight int64) {
 		expirationAge = time.Time{}
 	}
 
-	numExpired := txmp.store.purgeExpiredTxs(expirationHeight, expirationAge, txmp.evictedTxCache)
+	purgedTxs, numExpired := txmp.store.purgeExpiredTxs(expirationHeight, expirationAge)
+	// Add the purged transactions to the evicted cache
+	for _, tx := range purgedTxs {
+		txmp.evictedTxCache.Push(tx.key)
+	}
 	txmp.metrics.EvictedTxs.Add(float64(numExpired))
 
 	// purge old evicted and seen transactions

mempool/cat/pool_test.go

@@ -244,7 +244,7 @@ func TestTxPool_Eviction(t *testing.T) {
 	mustCheckTx(t, txmp, "key1=0000=25")
 	require.True(t, txExists("key1=0000=25"))
 	require.False(t, txExists(bigTx))
-	require.True(t, txmp.IsTxEvicted(types.Tx(bigTx).Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx(bigTx).Key()))
 	require.Equal(t, int64(len("key1=0000=25")), txmp.SizeBytes())
 
 	// Now fill up the rest of the slots with other transactions.
@@ -258,27 +258,27 @@ func TestTxPool_Eviction(t *testing.T) {
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "mempool is full")
 	require.False(t, txExists("key6=0005=1"))
-	require.True(t, txmp.IsTxEvicted(types.Tx("key6=0005=1").Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx("key6=0005=1").Key()))
 
 	// A new transaction with higher priority should evict key5, which is the
 	// newest of the two transactions with lowest priority.
 	mustCheckTx(t, txmp, "key7=0006=7")
 	require.True(t, txExists("key7=0006=7"))  // new transaction added
 	require.False(t, txExists("key5=0004=3")) // newest low-priority tx evicted
-	require.True(t, txmp.IsTxEvicted(types.Tx("key5=0004=3").Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx("key5=0004=3").Key()))
 	require.True(t, txExists("key4=0003=3")) // older low-priority tx retained
 
 	// Another new transaction evicts the other low-priority element.
 	mustCheckTx(t, txmp, "key8=0007=20")
 	require.True(t, txExists("key8=0007=20"))
 	require.False(t, txExists("key4=0003=3"))
-	require.True(t, txmp.IsTxEvicted(types.Tx("key4=0003=3").Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx("key4=0003=3").Key()))
 
 	// Now the lowest-priority tx is 5, so that should be the next to go.
 	mustCheckTx(t, txmp, "key9=0008=9")
 	require.True(t, txExists("key9=0008=9"))
 	require.False(t, txExists("key2=0001=5"))
-	require.True(t, txmp.IsTxEvicted(types.Tx("key2=0001=5").Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx("key2=0001=5").Key()))
 
 	// Add a transaction that requires eviction of multiple lower-priority
 	// entries, in order to fit the size of the element.
@@ -287,11 +287,11 @@ func TestTxPool_Eviction(t *testing.T) {
 	require.True(t, txExists("key8=0007=20"))
 	require.True(t, txExists("key10=0123456789abcdef=11"))
 	require.False(t, txExists("key3=0002=10"))
-	require.True(t, txmp.IsTxEvicted(types.Tx("key3=0002=10").Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx("key3=0002=10").Key()))
 	require.False(t, txExists("key9=0008=9"))
-	require.True(t, txmp.IsTxEvicted(types.Tx("key9=0008=9").Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx("key9=0008=9").Key()))
 	require.False(t, txExists("key7=0006=7"))
-	require.True(t, txmp.IsTxEvicted(types.Tx("key7=0006=7").Key()))
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx("key7=0006=7").Key()))
 
 	// Free up some space so we can add back previously evicted txs
 	err = txmp.Update(1, types.Txs{types.Tx("key10=0123456789abcdef=11")}, []*abci.ResponseDeliverTx{{Code: abci.CodeTypeOK}}, nil, nil)
@@ -304,7 +304,7 @@ func TestTxPool_Eviction(t *testing.T) {
 	// space for the previously evicted tx
 	require.NoError(t, txmp.RemoveTxByKey(types.Tx("key8=0007=20").Key()))
 	require.False(t, txExists("key8=0007=20"))
-	require.False(t, txmp.IsTxEvicted(types.Tx("key8=0007=20").Key()))
+	require.False(t, txmp.WasRecentlyEvicted(types.Tx("key8=0007=20").Key()))
 }
 
 func TestTxPool_Flush(t *testing.T) {
@@ -577,7 +577,7 @@ func TestTxPool_ExpiredTxs_Timestamp(t *testing.T) {
 	// All the transactions in the original set should have been purged.
 	for _, tx := range added1 {
 		// Check that it was added to the evictedTxCache
-		evicted := txmp.IsTxEvicted(tx.tx.Key())
+		evicted := txmp.WasRecentlyEvicted(tx.tx.Key())
 		require.True(t, evicted)
 
 		if txmp.store.has(tx.tx.Key()) {

mempool/cat/store.go

@@ -142,21 +142,22 @@ func (s *store) getTxsBelowPriority(priority int64) ([]*wrappedTx, int64) {
 
 // purgeExpiredTxs removes all transactions that are older than the given height
 // and time. Returns the amount of transactions that were removed
-func (s *store) purgeExpiredTxs(expirationHeight int64, expirationAge time.Time, evictedTxCache *LRUTxCache) int {
+func (s *store) purgeExpiredTxs(expirationHeight int64, expirationAge time.Time) ([]*wrappedTx, int) {
 	s.mtx.Lock()
 	defer s.mtx.Unlock()
+
+	var purgedTxs []*wrappedTx
 	counter := 0
+
 	for key, tx := range s.txs {
 		if tx.height < expirationHeight || tx.timestamp.Before(expirationAge) {
 			s.bytes -= tx.size()
 			delete(s.txs, key)
-			if evictedTxCache != nil {
-				evictedTxCache.Push(key)
-			}
+			purgedTxs = append(purgedTxs, tx)
 			counter++
 		}
 	}
-	return counter
+	return purgedTxs, counter
 }
 
 func (s *store) reset() {

mempool/cat/store_test.go

@@ -173,14 +173,14 @@ func TestStoreExpiredTxs(t *testing.T) {
 	}
 
 	// half of them should get purged
-	store.purgeExpiredTxs(int64(numTxs/2), time.Time{}, nil)
+	store.purgeExpiredTxs(int64(numTxs/2), time.Time{})
 
 	remainingTxs := store.getAllTxs()
 	require.Equal(t, numTxs/2, len(remainingTxs))
 	for _, tx := range remainingTxs {
 		require.GreaterOrEqual(t, tx.height, int64(numTxs/2))
 	}
 
-	store.purgeExpiredTxs(int64(0), time.Now().Add(time.Second), nil)
+	store.purgeExpiredTxs(int64(0), time.Now().Add(time.Second))
 	require.Empty(t, store.getAllTxs())
 }

mempool/mempool.go

@@ -91,14 +91,14 @@ type Mempool interface {
 	// trigger once every height when transactions are available.
 	EnableTxsAvailable()
 
-	// GetTxByKey gets a tx by its key from the mempool cache. Returns the tx and a bool indicating its presence in the tx cache.
+	// GetTxByKey gets a tx by its key from the mempool. Returns the tx and a bool indicating its presence in the tx cache.
 	// Used in the RPC endpoint: TxStatus.
 	GetTxByKey(key types.TxKey) (types.Tx, bool)
 
-	// IsTxEvicted returns true if the tx is evicted from the mempool and exists in the
+	// WasRecentlyEvicted returns true if the tx was evicted from the mempool and exists in the
 	// evicted cache.
 	// Used in the RPC endpoint: TxStatus.
-	IsTxEvicted(key types.TxKey) bool
+	WasRecentlyEvicted(key types.TxKey) bool
 
 	// Size returns the number of transactions in the mempool.
 	Size() int

mempool/mock/mempool.go

@@ -36,7 +36,7 @@ func (Mempool) TxsAvailable() <-chan struct{}             { return make(chan str
 func (Mempool) EnableTxsAvailable()                       {}
 func (Mempool) SizeBytes() int64                          { return 0 }
 func (m Mempool) GetTxByKey(types.TxKey) (types.Tx, bool) { return nil, false }
-func (m Mempool) IsTxEvicted(types.TxKey) bool            { return false }
+func (m Mempool) WasRecentlyEvicted(types.TxKey) bool     { return false }
 func (Mempool) TxsFront() *clist.CElement                 { return nil }
 func (Mempool) TxsWaitChan() <-chan struct{}              { return nil }
 

mempool/v0/clist_mempool.go

@@ -183,13 +183,18 @@ func (mem *CListMempool) TxsFront() *clist.CElement {
 	return mem.txs.Front()
 }
 
-// GetTxByKey is not supported by the v0 mempool but it is required to satisfy the mempool interface.
+// GetTxByKey retrieves a transaction from the mempool using its key.
 func (mem *CListMempool) GetTxByKey(key types.TxKey) (types.Tx, bool) {
-	return nil, false
+	e, ok := mem.txsMap.Load(key)
+	if !ok {
+		return nil, false
+	}
+	memTx, ok := e.(*clist.CElement).Value.(*mempoolTx)
+	return memTx.tx, ok
 }
 
-// IsTxEvicted is not supported by the v0 mempool but it is required to satisfy the mempool interface.
-func (mem *CListMempool) IsTxEvicted(key types.TxKey) bool {
+// WasRecentlyEvicted returns false consistently as this implementation does not support transaction eviction.
+func (mem *CListMempool) WasRecentlyEvicted(key types.TxKey) bool {
 	return false
 }
 

mempool/v0/clist_mempool_test.go

@@ -549,6 +549,32 @@ func TestMempool_CheckTxChecksTxSize(t *testing.T) {
 	}
 }
 
+func TestGetTxByKey(t *testing.T) {
+	app := kvstore.NewApplication()
+	cc := proxy.NewLocalClientCreator(app)
+
+	mp, cleanup := newMempoolWithApp(cc)
+	defer cleanup()
+
+	// Create a tx
+	tx := types.Tx([]byte{0x01})
+	// Add it to the mempool
+	err := mp.CheckTx(tx, nil, mempool.TxInfo{})
+	require.NoError(t, err)
+
+	// Query the tx from the mempool
+	got, ok := mp.GetTxByKey(tx.Key())
+	require.True(t, ok)
+	// Ensure the returned tx is the same as the one we added
+	require.Equal(t, tx, got)
+
+	// Query a random tx from the mempool
+	randomTx, ok := mp.GetTxByKey(types.Tx([]byte{0x02}).Key())
+	// Ensure the returned tx is nil
+	require.False(t, ok)
+	require.Nil(t, randomTx)
+}
+
 func TestMempoolTxsBytes(t *testing.T) {
 	app := kvstore.NewApplication()
 	cc := proxy.NewLocalClientCreator(app)

mempool/v1/mempool.go

@@ -87,7 +87,7 @@ func NewTxMempool(
 	}
 	if cfg.CacheSize > 0 {
 		txmp.cache = mempool.NewLRUTxCache(cfg.CacheSize)
-		txmp.evictedTxs = mempool.NewLRUTxCache(cfg.CacheSize)
+		txmp.evictedTxs = mempool.NewLRUTxCache(cfg.CacheSize / 5)
 	}
 
 	for _, opt := range options {
@@ -273,9 +273,9 @@ func (txmp *TxMempool) GetTxByKey(txKey types.TxKey) (types.Tx, bool) {
 	return nil, false
 }
 
-// IsTxEvicted returns a bool indicating whether the transaction with
-// the specified key was recently evicted and is currently within the cache.
-func (txmp *TxMempool) IsTxEvicted(txKey types.TxKey) bool {
+// WasRecentlyEvicted returns a bool indicating whether the transaction with
+// the specified key was recently evicted and is currently within the evicted cache.
+func (txmp *TxMempool) WasRecentlyEvicted(txKey types.TxKey) bool {
 	return txmp.evictedTxs.HasKey(txKey)
 }
 

mempool/v1/mempool_test.go

@@ -243,7 +243,7 @@ func TestTxMempool_Eviction(t *testing.T) {
 	require.False(t, txExists(bigTx))
 	bigTxKey := types.Tx((bigTx)).Key()
 	require.False(t, txmp.cache.HasKey(bigTxKey))
-	require.True(t, txmp.IsTxEvicted(bigTxKey)) // bigTx evicted
+	require.True(t, txmp.WasRecentlyEvicted(bigTxKey)) // bigTx evicted
 	require.Equal(t, int64(len("key1=0000=25")), txmp.SizeBytes())
 
 	// Now fill up the rest of the slots with other transactions.
@@ -255,15 +255,15 @@ func TestTxMempool_Eviction(t *testing.T) {
 	// A new transaction with low priority should be discarded.
 	mustCheckTx(t, txmp, "key6=0005=1")
 	require.False(t, txExists("key6=0005=1"))
-	require.True(t, txmp.IsTxEvicted(types.Tx(("key6=0005=1")).Key())) // key6 evicted
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx(("key6=0005=1")).Key())) // key6 evicted
 
 	// A new transaction with higher priority should evict key5, which is the
 	// newest of the two transactions with lowest priority.
 	mustCheckTx(t, txmp, "key7=0006=7")
-	require.True(t, txExists("key7=0006=7"))                           // new transaction added
-	require.False(t, txExists("key5=0004=3"))                          // newest low-priority tx evicted
-	require.True(t, txmp.IsTxEvicted(types.Tx(("key5=0004=3")).Key())) // key5 evicted
-	require.True(t, txExists("key4=0003=3"))                           // older low-priority tx retained
+	require.True(t, txExists("key7=0006=7"))                                  // new transaction added
+	require.False(t, txExists("key5=0004=3"))                                 // newest low-priority tx evicted
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx(("key5=0004=3")).Key())) // key5 evicted
+	require.True(t, txExists("key4=0003=3"))                                  // older low-priority tx retained
 
 	// Another new transaction evicts the other low-priority element.
 	mustCheckTx(t, txmp, "key8=0007=20")
@@ -274,7 +274,7 @@ func TestTxMempool_Eviction(t *testing.T) {
 	mustCheckTx(t, txmp, "key9=0008=9")
 	require.True(t, txExists("key9=0008=9"))
 	require.False(t, txExists("key2=0001=5"))
-	require.True(t, txmp.IsTxEvicted(types.Tx(("key2=0001=5")).Key())) // key2 evicted
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx(("key2=0001=5")).Key())) // key2 evicted
 
 	// Add a transaction that requires eviction of multiple lower-priority
 	// entries, in order to fit the size of the element.
@@ -283,11 +283,11 @@ func TestTxMempool_Eviction(t *testing.T) {
 	require.True(t, txExists("key8=0007=20"))
 	require.True(t, txExists("key10=0123456789abcdef=11"))
 	require.False(t, txExists("key3=0002=10"))
-	require.True(t, txmp.IsTxEvicted(types.Tx(("key3=0002=10")).Key())) // key3 evicted
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx(("key3=0002=10")).Key())) // key3 evicted
 	require.False(t, txExists("key9=0008=9"))
-	require.True(t, txmp.IsTxEvicted(types.Tx(("key9=0008=9")).Key())) // key9 evicted
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx(("key9=0008=9")).Key())) // key9 evicted
 	require.False(t, txExists("key7=0006=7"))
-	require.True(t, txmp.IsTxEvicted(types.Tx(("key7=0006=7")).Key())) // key7 evicted
+	require.True(t, txmp.WasRecentlyEvicted(types.Tx(("key7=0006=7")).Key())) // key7 evicted
 }
 
 func TestTxMempool_Flush(t *testing.T) {
@@ -591,7 +591,7 @@ func TestTxMempool_ExpiredTxs_Timestamp(t *testing.T) {
 	// All the transactions in the original set should have been purged.
 	for _, tx := range added1 {
 		// Check that they were added to the evicted cache.
-		evicted := txmp.IsTxEvicted(tx.tx.Key())
+		evicted := txmp.WasRecentlyEvicted(tx.tx.Key())
 		require.True(t, evicted)
 
 		if _, ok := txmp.txByKey[tx.tx.Key()]; ok {