core/txpool: add back sorting by time

Author: holiman

core/txpool/blobpool/blobpool.go

@@ -1519,6 +1519,7 @@ func (p *BlobPool) Pending(filter txpool.PendingFilter) txpool.Pending {
 				heads = append(heads, &txpool.TxTips{
 					From: addr,
 					Tips: lazyTx.Fees,
+					Time: lazyTx.Time.UnixNano(),
 				})
 			}
 			tail = append(tail, lazyTx)

core/txpool/legacypool/legacypool.go

@@ -581,6 +581,7 @@ func (pool *LegacyPool) Pending(filter txpool.PendingFilter) txpool.Pending {
 				heads = append(heads, &txpool.TxTips{
 					From: addr,
 					Tips: lazyTx.Fees,
+					Time: lazyTx.Time.UnixNano(),
 				})
 			}
 			tail = append(tail, lazyTx)

core/txpool/pending.go

@@ -62,6 +62,7 @@ type PendingFilter struct {
 type TxTips struct {
 	From common.Address // sender
 	Tips uint256.Int    // miner-fees earned by this transaction.
+	Time int64          // Time when the transaction was first seen
 }
 
 type TipList []*TxTips
@@ -71,7 +72,12 @@ func (f TipList) Len() int {
 }
 
 func (f TipList) Less(i, j int) bool {
-	return f[i].Tips.Gt(&f[j].Tips)
+
+	cmp := f[i].Tips.Cmp(&f[j].Tips)
+	if cmp == 0 {
+		return f[i].Time < f[j].Time
+	}
+	return cmp > 0
 }
 
 func (f TipList) Swap(i, j int) {
@@ -113,6 +119,7 @@ func (ps *pendingSet) Shift() {
 	acc := ps.Heads[0].From
 	if txs, ok := ps.Tails[acc]; ok && len(txs) > 1 {
 		ps.Heads[0].Tips = txs[1].Fees
+		ps.Heads[0].Time = txs[1].Time.UnixNano()
 		ps.Tails[acc] = txs[1:]
 		heap.Fix(&ps.Heads, 0)
 		return

core/txpool/pending_test.go

@@ -17,6 +17,7 @@
 package txpool
 
 import (
+	"container/heap"
 	"math/rand"
 	"testing"
 
@@ -48,6 +49,7 @@ func initLists() (heads TipList, tails map[common.Address][]*LazyTransaction) {
 				heads = append(heads, &TxTips{
 					From: addr,
 					Tips: lazyTx.Fees,
+					Time: 0,
 				})
 			}
 			tail = append(tail, lazyTx)
@@ -126,17 +128,24 @@ func TestPendingSortAndPop(t *testing.T) {
 // Tests that if multiple transactions have the same price, the ones seen earlier
 // are prioritized to avoid network spam attacks aiming for a specific ordering.
 func TestSortingByTime(t *testing.T) {
-	t.Skip("The TipList does not take time into account. Should it? ")
-	//var heads TipList
-	//for i := 0; i < 25; i++ {
-	//	addr := common.Address{byte(i)}
-	//	heads = append(heads, &TxTips{
-	//		From: addr,
-	//		Tips: uint256.NewInt(uint64(100)),
-	//	})
-	//}
-	//// un-sort the heads
-	//rand.Shuffle(len(heads), func(i, j int) {
-	//	heads[i], heads[j] = heads[j], heads[i]
-	//})
+	var heads TipList
+	for i := 0; i < 25; i++ {
+		addr := common.Address{byte(i)}
+		heads = append(heads, &TxTips{
+			From: addr,
+			Tips: *(uint256.NewInt(uint64(100))),
+			Time: int64(i),
+		})
+	}
+	// un-sort the heads
+	rand.Shuffle(len(heads), func(i, j int) {
+		heads[i], heads[j] = heads[j], heads[i]
+	})
+	heap.Init(&heads)
+	for want := int64(0); want < 25; want++ {
+		obj := heap.Pop(&heads).(*TxTips)
+		if have := obj.Time; have != want {
+			t.Fatalf("have %d want %d", have, want)
+		}
+	}
 }

eth/handler_test.go

@@ -137,6 +137,7 @@ func (p *testTxPool) Pending(filter txpool.PendingFilter) txpool.Pending {
 				heads = append(heads, &txpool.TxTips{
 					From: addr,
 					Tips: *tip,
+					Time: ltx.Time.UnixNano(),
 				})
 			}
 		}

miner/worker.go

@@ -585,6 +585,7 @@ func (w *worker) mainLoop() {
 						heads = append(heads, &txpool.TxTips{
 							From: acc,
 							Tips: *fees,
+							Time: lazyTx.Time.UnixNano(),
 						})
 					}
 					txs[acc] = append(txs[acc], lazyTx)