Don't be notified about account nonces, don't store them; get them at selection-time

common/errors.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"errors"
+
 	"github.com/multiversx/mx-chain-core-go/core"
 )
 
@@ -74,6 +75,9 @@ var ErrNilTimeCache = errors.New("nil time cache")
 // ErrNilTxGasHandler signals that a nil tx gas handler was provided
 var ErrNilTxGasHandler = errors.New("nil tx gas handler")
 
+// ErrNilAccountNonceProvider signals that a nil account nonce provider was provided
+var ErrNilAccountNonceProvider = errors.New("nil account nonce provider")
+
 // ErrNilStoredDataFactory signals that a nil stored data factory has been provided
 var ErrNilStoredDataFactory = errors.New("nil stored data factory")
 

testscommon/txcachemocks/accountNonceProviderMock.go

@@ -0,0 +1,37 @@
+package txcachemocks
+
+import (
+	"errors"
+)
+
+// AccountNonceProviderMock -
+type AccountNonceProviderMock struct {
+	NoncesByAddress       map[string]uint64
+	GetAccountNonceCalled func(address []byte) (uint64, error)
+}
+
+// NewAccountNonceProviderMock -
+func NewAccountNonceProviderMock() *AccountNonceProviderMock {
+	return &AccountNonceProviderMock{
+		NoncesByAddress: make(map[string]uint64),
+	}
+}
+
+// GetAccountNonce -
+func (stub *AccountNonceProviderMock) GetAccountNonce(address []byte) (uint64, error) {
+	if stub.GetAccountNonceCalled != nil {
+		return stub.GetAccountNonceCalled(address)
+	}
+
+	nonce, ok := stub.NoncesByAddress[string(address)]
+	if !ok {
+		return 0, errors.New("cannot get nonce")
+	}
+
+	return nonce, nil
+}
+
+// IsInterfaceNil -
+func (stub *AccountNonceProviderMock) IsInterfaceNil() bool {
+	return stub == nil
+}

txcache/README.md

@@ -114,7 +114,7 @@ The mempool selects transactions as follows (pseudo-code):
 func selectTransactions(gasRequested, maxNum):
     // Setup phase
     senders := list of all current senders in the mempool, in an arbitrary order
-    bunchesOfTransactions := sourced from senders; nonces-gap-free, duplicates-free, nicely sorted by nonce
+    bunchesOfTransactions := sourced from senders; middle-nonces-gap-free, duplicates-free, nicely sorted by nonce
 
     // Holds selected transactions
     selectedTransactions := empty
@@ -154,7 +154,7 @@ Thus, the mempool selects transactions using an efficient and value-driven algor
    - **Organize transactions into bunches:**
      - For each sender, collect all their pending transactions and organize them into a "bunch."
      - Each bunch is:
-       - **Nonce-gap-free:** There are no missing nonces between transactions.
+       - **Middle-nonces-gap-free:** There are no missing nonces between transactions.
        - **Duplicates-free:** No duplicate transactions are included.
        - **Sorted by nonce:** Transactions are ordered in ascending order based on their nonce values.
 
@@ -181,6 +181,10 @@ Thus, the mempool selects transactions using an efficient and value-driven algor
        - The accumulated gas of selected transactions meets or exceeds `gasRequested`.
        - The number of selected transactions reaches `maxNum`.
 
+**Additional notes:**
+ - Within the selection loop, the current nonce of the sender is queryied from the blockchain, if necessary.
+ - If an initial nonce gap is detected, the sender is excluded from the selection process.
+ - Transactions with nonces lower than the current nonce of the sender are skipped (not included in the selection).
 
 ### Paragraph 5
 

txcache/crossTxCache.go

@@ -115,14 +115,6 @@ func (cache *CrossTxCache) GetTransactionsPoolForSender(_ string) []*WrappedTran
 	return make([]*WrappedTransaction, 0)
 }
 
-// NotifyAccountNonce does nothing, only to respect the interface
-func (cache *CrossTxCache) NotifyAccountNonce(_ []byte, _ uint64) {
-}
-
-// ForgetAllAccountNonces does nothing, only to respect the interface
-func (cache *CrossTxCache) ForgetAllAccountNonces() {
-}
-
 // IsInterfaceNil returns true if there is no value under the interface
 func (cache *CrossTxCache) IsInterfaceNil() bool {
 	return cache == nil

txcache/disabledCache.go

@@ -105,14 +105,6 @@ func (cache *DisabledCache) RegisterHandler(func(key []byte, value interface{}),
 func (cache *DisabledCache) UnRegisterHandler(string) {
 }
 
-// NotifyAccountNonce does nothing
-func (cache *DisabledCache) NotifyAccountNonce(_ []byte, _ uint64) {
-}
-
-// ForgetAllAccountNonces does nothing
-func (cache *DisabledCache) ForgetAllAccountNonces() {
-}
-
 // ImmunizeTxsAgainstEviction does nothing
 func (cache *DisabledCache) ImmunizeTxsAgainstEviction(_ [][]byte) {
 }

txcache/eviction_test.go

@@ -21,8 +21,11 @@ func TestTxCache_DoEviction_BecauseOfCount(t *testing.T) {
 		EvictionEnabled:             true,
 		NumItemsToPreemptivelyEvict: 1,
 	}
+
 	txGasHandler := txcachemocks.NewTxGasHandlerMock()
-	cache, err := NewTxCache(config, txGasHandler)
+	accountNonceProvider := txcachemocks.NewAccountNonceProviderMock()
+
+	cache, err := NewTxCache(config, txGasHandler, accountNonceProvider)
 	require.Nil(t, err)
 	require.NotNil(t, cache)
 
@@ -56,7 +59,9 @@ func TestTxCache_DoEviction_BecauseOfSize(t *testing.T) {
 	}
 
 	txGasHandler := txcachemocks.NewTxGasHandlerMock()
-	cache, err := NewTxCache(config, txGasHandler)
+	accountNonceProvider := txcachemocks.NewAccountNonceProviderMock()
+
+	cache, err := NewTxCache(config, txGasHandler, accountNonceProvider)
 	require.Nil(t, err)
 	require.NotNil(t, cache)
 
@@ -91,7 +96,9 @@ func TestTxCache_DoEviction_DoesNothingWhenAlreadyInProgress(t *testing.T) {
 	}
 
 	txGasHandler := txcachemocks.NewTxGasHandlerMock()
-	cache, err := NewTxCache(config, txGasHandler)
+	accountNonceProvider := txcachemocks.NewAccountNonceProviderMock()
+
+	cache, err := NewTxCache(config, txGasHandler, accountNonceProvider)
 	require.Nil(t, err)
 	require.NotNil(t, cache)
 
@@ -129,11 +136,12 @@ func TestBenchmarkTxCache_DoEviction(t *testing.T) {
 	}
 
 	txGasHandler := txcachemocks.NewTxGasHandlerMock()
+	accountNonceProvider := txcachemocks.NewAccountNonceProviderMock()
 
 	sw := core.NewStopWatch()
 
 	t.Run("numSenders = 35000, numTransactions = 10", func(t *testing.T) {
-		cache, err := NewTxCache(config, txGasHandler)
+		cache, err := NewTxCache(config, txGasHandler, accountNonceProvider)
 		require.Nil(t, err)
 
 		cache.config.EvictionEnabled = false
@@ -151,7 +159,7 @@ func TestBenchmarkTxCache_DoEviction(t *testing.T) {
 	})
 
 	t.Run("numSenders = 100000, numTransactions = 5", func(t *testing.T) {
-		cache, err := NewTxCache(config, txGasHandler)
+		cache, err := NewTxCache(config, txGasHandler, accountNonceProvider)
 		require.Nil(t, err)
 
 		cache.config.EvictionEnabled = false
@@ -169,7 +177,7 @@ func TestBenchmarkTxCache_DoEviction(t *testing.T) {
 	})
 
 	t.Run("numSenders = 400000, numTransactions = 1", func(t *testing.T) {
-		cache, err := NewTxCache(config, txGasHandler)
+		cache, err := NewTxCache(config, txGasHandler, accountNonceProvider)
 		require.Nil(t, err)
 
 		cache.config.EvictionEnabled = false
@@ -187,7 +195,7 @@ func TestBenchmarkTxCache_DoEviction(t *testing.T) {
 	})
 
 	t.Run("numSenders = 10000, numTransactions = 100", func(t *testing.T) {
-		cache, err := NewTxCache(config, txGasHandler)
+		cache, err := NewTxCache(config, txGasHandler, accountNonceProvider)
 		require.Nil(t, err)
 
 		cache.config.EvictionEnabled = false

txcache/interface.go

@@ -12,5 +12,11 @@ type TxGasHandler interface {
 	IsInterfaceNil() bool
 }
 
+// AccountNonceProvider defines the behavior of a component able to provide the nonce for an account
+type AccountNonceProvider interface {
+	GetAccountNonce(accountKey []byte) (uint64, error)
+	IsInterfaceNil() bool
+}
+
 // ForEachTransaction is an iterator callback
 type ForEachTransaction func(txHash []byte, value *WrappedTransaction)

txcache/selection.go

@@ -2,6 +2,8 @@ package txcache
 
 import (
 	"container/heap"
+
+	logger "github.com/multiversx/mx-chain-logger-go"
 )
 
 func (cache *TxCache) doSelectTransactions(gasRequested uint64, maxNum int) (bunchOfTransactions, uint64) {
@@ -12,11 +14,11 @@ func (cache *TxCache) doSelectTransactions(gasRequested uint64, maxNum int) (bun
 		bunches = append(bunches, sender.getSequentialTxs())
 	}
 
-	return selectTransactionsFromBunches(bunches, gasRequested, maxNum)
+	return cache.selectTransactionsFromBunches(bunches, gasRequested, maxNum)
 }
 
 // Selection tolerates concurrent transaction additions / removals.
-func selectTransactionsFromBunches(bunches []bunchOfTransactions, gasRequested uint64, maxNum int) (bunchOfTransactions, uint64) {
+func (cache *TxCache) selectTransactionsFromBunches(bunches []bunchOfTransactions, gasRequested uint64, maxNum int) (bunchOfTransactions, uint64) {
 	selectedTransactions := make(bunchOfTransactions, 0, initialCapacityOfSelectionSlice)
 
 	// Items popped from the heap are added to "selectedTransactions".
@@ -45,6 +47,7 @@ func selectTransactionsFromBunches(bunches []bunchOfTransactions, gasRequested u
 		// Always pick the best transaction.
 		item := heap.Pop(transactionsHeap).(*transactionsHeapItem)
 		gasLimit := item.transaction.Tx.GetGasLimit()
+		nonce := item.transaction.Tx.GetNonce()
 
 		if accumulatedGas+gasLimit > gasRequested {
 			break
@@ -53,8 +56,40 @@ func selectTransactionsFromBunches(bunches []bunchOfTransactions, gasRequested u
 			break
 		}
 
-		accumulatedGas += gasLimit
-		selectedTransactions = append(selectedTransactions, item.transaction)
+		cache.askAboutAccountNonceIfNecessary(item)
+
+		isInitialGap := item.transactionIndex == 0 && item.senderNonceTold && nonce > item.senderNonce
+		if isInitialGap {
+			if logSelect.GetLevel() <= logger.LogTrace {
+				logSelect.Trace("TxCache.selectTransactionsFromBunches, initial gap",
+					"tx", item.transaction.TxHash,
+					"nonce", nonce,
+					"sender", item.transaction.Tx.GetSndAddr(),
+					"senderNonce", item.senderNonce,
+				)
+			}
+
+			// Item was popped from the heap, but not used downstream.
+			// Therefore, the sender is completely ignored in the current selection session.
+			continue
+		}
+
+		isLowerNonce := item.senderNonceTold && nonce < item.senderNonce
+		if isLowerNonce {
+			if logSelect.GetLevel() <= logger.LogTrace {
+				logSelect.Trace("TxCache.selectTransactionsFromBunches, lower nonce",
+					"tx", item.transaction.TxHash,
+					"nonce", nonce,
+					"sender", item.transaction.Tx.GetSndAddr(),
+					"senderNonce", item.senderNonce,
+				)
+			}
+
+			// Transaction isn't selected, but the sender is still in the game (will contribute with other transactions).
+		} else {
+			accumulatedGas += gasLimit
+			selectedTransactions = append(selectedTransactions, item.transaction)
+		}
 
 		// If there are more transactions in the same bunch (same sender as the popped item),
 		// add the next one to the heap (to compete with the others).
@@ -69,3 +104,22 @@ func selectTransactionsFromBunches(bunches []bunchOfTransactions, gasRequested u
 
 	return selectedTransactions, accumulatedGas
 }
+
+func (cache *TxCache) askAboutAccountNonceIfNecessary(item *transactionsHeapItem) {
+	if item.senderNonceAsked {
+		return
+	}
+
+	item.senderNonceAsked = true
+
+	sender := item.transaction.Tx.GetSndAddr()
+	senderNonce, err := cache.accountNonceProvider.GetAccountNonce(sender)
+	if err != nil {
+		// Hazardous; should never happen.
+		logSelect.Debug("TxCache.askAboutAccountNonceIfNecessary: nonce not available", "sender", sender, "err", err)
+		return
+	}
+
+	item.senderNonceTold = true
+	item.senderNonce = senderNonce
+}