feat: sender mempool impl

types/mempool/mempool_test.go

@@ -132,6 +132,7 @@ func (s *MempoolTestSuite) TestDefaultMempool() {
 	for i := 0; i < txCount; i++ {
 		acc := accounts[i%len(accounts)]
 		tx := testTx{
+			nonce:    0,
 			address:  acc.Address,
 			priority: rand.Int63(),
 		}
@@ -201,7 +202,7 @@ type MempoolTestSuite struct {
 
 func (s *MempoolTestSuite) resetMempool() {
 	s.iterations = 0
-	s.mempool = mempool.NewNonceMempool()
+	s.mempool = mempool.NewSenderNonceMempool()
 }
 
 func (s *MempoolTestSuite) SetupTest() {

types/mempool/nonce_test.go

@@ -2,6 +2,7 @@ package mempool_test
 
 import (
 	"fmt"
+	"github.com/cosmos/cosmos-sdk/types/mempool"
 	"math/rand"
 	"testing"
 
@@ -19,12 +20,13 @@ func (s *MempoolTestSuite) TestTxOrder() {
 	accounts := simtypes.RandomAccounts(rand.New(rand.NewSource(0)), 5)
 	sa := accounts[0].Address
 	sb := accounts[1].Address
-	sc := accounts[2].Address
+	//sc := accounts[2].Address
 
 	tests := []struct {
 		txs   []txSpec
-		order []int
+		order [][]int
 		fail  bool
+		seed  int64
 	}{
 		{
 			txs: []txSpec{
@@ -34,7 +36,12 @@ func (s *MempoolTestSuite) TestTxOrder() {
 				{p: 15, n: 1, a: sb},
 				{p: 20, n: 1, a: sa},
 			},
-			order: []int{3, 4, 2, 1, 0},
+			order: [][]int{
+				{4, 2, 3, 1, 0},
+				{3, 4, 2, 1, 0},
+			},
+			// Index order base on seed 0: 0  0  1  0  1  0  0
+			seed: 0,
 		},
 		{
 			txs: []txSpec{
@@ -45,15 +52,25 @@ func (s *MempoolTestSuite) TestTxOrder() {
 				{p: 5, n: 1, a: sb},
 				{p: 8, n: 2, a: sb},
 			},
-			order: []int{3, 0, 4, 1, 5, 2},
+			order: [][]int{
+				{0, 1, 3, 2, 4, 5},
+				{3, 4, 0, 5, 1, 2},
+			},
+			// Index order base on seed 0: 0  0  1  0  1  0  0
+			seed: 0,
 		},
 		{
 			txs: []txSpec{
 				{p: 21, n: 4, a: sa},
 				{p: 15, n: 1, a: sb},
 				{p: 20, n: 1, a: sa},
 			},
-			order: []int{1, 2, 0},
+			order: [][]int{
+				{2, 0, 1},
+				{1, 2, 0},
+			},
+			// Index order base on seed 0: 0  0  1  0  1  0  0
+			seed: 0,
 		},
 		{
 			txs: []txSpec{
@@ -63,7 +80,12 @@ func (s *MempoolTestSuite) TestTxOrder() {
 				{p: 15, n: 1, a: sb},
 				{p: 21, n: 2, a: sb},
 			},
-			order: []int{3, 2, 4, 1, 0},
+			order: [][]int{
+				{2, 1, 3, 0, 4},
+				{3, 4, 2, 1, 0},
+			},
+			// Index order base on seed 0: 0  0  1  0  1  0  0
+			seed: 0,
 		},
 		{
 			txs: []txSpec{
@@ -73,7 +95,12 @@ func (s *MempoolTestSuite) TestTxOrder() {
 				{p: 15, n: 1, a: sb},
 				{p: 8, n: 2, a: sb},
 			},
-			order: []int{3, 2, 4, 1, 0},
+			order: [][]int{
+				{2, 1, 3, 0, 4},
+				{3, 4, 2, 1, 0},
+			},
+			// Index order base on seed 0: 0  0  1  0  1  0  0
+			seed: 0,
 		},
 		{
 			txs: []txSpec{
@@ -85,21 +112,12 @@ func (s *MempoolTestSuite) TestTxOrder() {
 				{p: 6, a: sa, n: 3},
 				{p: 4, a: sb, n: 3},
 			},
-			order: []int{4, 3, 1, 2, 0, 6, 5},
-		},
-		{
-			txs: []txSpec{
-				{p: 30, n: 2, a: sa},
-				{p: 20, a: sb, n: 1},
-				{p: 15, a: sa, n: 1},
-				{p: 10, a: sa, n: 0},
-				{p: 8, a: sb, n: 0},
-				{p: 6, a: sa, n: 3},
-				{p: 4, a: sb, n: 3},
-				{p: 2, a: sc, n: 0},
-				{p: 7, a: sc, n: 3},
+			order: [][]int{
+				{3, 2, 4, 0, 1, 5, 6},
+				{4, 1, 3, 6, 2, 0, 5},
 			},
-			order: []int{4, 3, 7, 1, 2, 0, 6, 5, 8},
+			// Index order base on seed 0: 0  0  1  0  1  0  1 1 0
+			seed: 0,
 		},
 		{
 			txs: []txSpec{
@@ -108,83 +126,17 @@ func (s *MempoolTestSuite) TestTxOrder() {
 				{p: 5, n: 1, a: sb},
 				{p: 99, n: 2, a: sb},
 			},
-			order: []int{2, 0, 3, 1},
-		},
-		{
-			// if all txs have the same priority they will be ordered lexically sender address, and nonce with the
-			// sender.
-			txs: []txSpec{
-				{p: 10, n: 7, a: sc},
-				{p: 10, n: 8, a: sc},
-				{p: 10, n: 9, a: sc},
-				{p: 10, n: 1, a: sa},
-				{p: 10, n: 2, a: sa},
-				{p: 10, n: 3, a: sa},
-				{p: 10, n: 4, a: sb},
-				{p: 10, n: 5, a: sb},
-				{p: 10, n: 6, a: sb},
+			order: [][]int{
+				{0, 1, 2, 3},
+				{2, 3, 0, 1},
 			},
-			order: []int{3, 4, 5, 6, 7, 8, 0, 1, 2},
-		},
-		/*
-			The next 4 tests are different permutations of the same set:
-
-			  		{p: 5, n: 1, a: sa},
-					{p: 10, n: 2, a: sa},
-					{p: 20, n: 2, a: sb},
-					{p: 5, n: 1, a: sb},
-					{p: 99, n: 2, a: sc},
-					{p: 5, n: 1, a: sc},
-
-			which exercises the actions required to resolve priority ties.
-		*/
-		{
-			txs: []txSpec{
-				{p: 5, n: 1, a: sa},
-				{p: 10, n: 2, a: sa},
-				{p: 5, n: 1, a: sb},
-				{p: 99, n: 2, a: sb},
-			},
-			order: []int{2, 0, 3, 1},
-		},
-		{
-			txs: []txSpec{
-				{p: 5, n: 1, a: sa},
-				{p: 10, n: 2, a: sa},
-				{p: 20, n: 2, a: sb},
-				{p: 5, n: 1, a: sb},
-				{p: 99, n: 2, a: sc},
-				{p: 5, n: 1, a: sc},
-			},
-			order: []int{3, 0, 5, 2, 1, 4},
-		},
-		{
-			txs: []txSpec{
-				{p: 5, n: 1, a: sa},
-				{p: 10, n: 2, a: sa},
-				{p: 5, n: 1, a: sb},
-				{p: 20, n: 2, a: sb},
-				{p: 5, n: 1, a: sc},
-				{p: 99, n: 2, a: sc},
-			},
-			order: []int{2, 0, 4, 3, 1, 5},
-		},
-		{
-			txs: []txSpec{
-				{p: 5, n: 1, a: sa},
-				{p: 10, n: 2, a: sa},
-				{p: 5, n: 1, a: sc},
-				{p: 20, n: 2, a: sc},
-				{p: 5, n: 1, a: sb},
-				{p: 99, n: 2, a: sb},
-			},
-			order: []int{4, 0, 2, 5, 1, 3},
+			// Index order base on seed 0: 0  0  1  0  1  0  1 1 0
+			seed: 0,
 		},
 	}
 	for i, tt := range tests {
 		t.Run(fmt.Sprintf("case %d", i), func(t *testing.T) {
-			pool := s.mempool
-
+			pool := mempool.NewSenderNonceMempoolWithSeed(tt.seed)
 			// create test txs and insert into mempool
 			for i, ts := range tt.txs {
 				tx := testTx{id: i, priority: int64(ts.p), nonce: uint64(ts.n), address: ts.a}
@@ -202,9 +154,12 @@ func (s *MempoolTestSuite) TestTxOrder() {
 			for _, tx := range orderedTxs {
 				require.NoError(t, pool.Remove(tx))
 			}
-
-			require.Equal(t, tt.order, txOrder)
+			require.Contains(t, fmt.Sprintf("%v", tt.order), fmt.Sprintf("%v", txOrder))
 			require.Equal(t, 0, pool.CountTx())
 		})
 	}
 }
+
+func (s *MempoolTestSuite) TestNormalDistributionTxSelection() {
+
+}