miner, core/txpool: refactor processing of pending transactions

[holiman]

This PR is work in progress, based on the comment made here: #29008 (comment)

This PR changes the format of Pending from subpool. It now returns

type pendingSet struct {
	Tails map[common.Address][]*LazyTransaction // Per account nonce-sorted list of transactions
	Heads FeeList                               // Next transaction for each unique account (price heap)
}

The Tails is simply all pending transactions, in a map.
The Heads is a list of address, fee, denoting the fee of the first tx from each account. It is a heap.

The pendingSet supports operations that were previously implemented by transactionsByPriceAndNonce :

type Pending interface {
	// Shift replaces the current best head with the next one from the same account.
	Shift()
	// Peek returns the next transaction by price.
	Peek() (*LazyTransaction, *uint256.Int)

	// Pop removes the best transaction, *not* replacing it with the next one from
	// the same account. This should be used when a transaction cannot be executed
	// and hence all subsequent ones should be discarded from the same account.
	Pop()

	// Empty returns true if the set is empty.
	Empty() bool

	// Clears the set
	Clear()
}

---

There are several TODOs

• Implement PendingHashes (used in simulated and eth/sync
• Handle incoming txs in worker.mainLoop
• Add some mechanism to filter out blob-txs / disable blobpool pendings from miner
• Re-add locals-handling
• Benchmark block building vs master

[holiman]

The filter.OnlyXXX ought to be a single boolean, to denote always one xor the other.

[holiman]

This thing is getting kind of big. Perhaps, instead of passing around a PendingFilter, we should pass around *PendingFilter, which in turn could have uint256.Int fields instead of *uint256.Int?

[holiman]

I added this function. It serves as backend for PendingHashes, which is used e.g. when we meet another peer on the network, and need to exchange hashes. This happens quite often, so I figured it might be worth optimizing a bit.
With this change, we just allocate the slice of hashes once, and then we just iterate the flattened cached list and append them.
The method Flatten copies the cache in an intermediate step, to prevent accidental modification. So this allows us to skip that step.

[holiman]

Originally, I had two types implementing this. Now there's only pendingSet. I'm torn if we should keep this as an interface or not. Open to suggestions.

[lightclient]

Looks like you dropped the if filter.BaseFee != nil branch?

[lightclient]

probably want some docs for these?

[MariusVanDerWijden]

This seems like a nice idea, but the PR has bitrotted over time, so I'm wondering if you want to pick this up again @holiman or if we should close this and open an issue with the idea so we don't forget about it