core, eth, miner: rebase on latest blobpool

Author: MariusVanDerWijden

core/txpool/blobpool/blobpool.go

@@ -326,7 +326,6 @@ func New(config Config, chain BlockChain) *BlobPool {
 		lookup: make(map[common.Hash]uint64),
 		index:  make(map[common.Address][]*blobTxMeta),
 		spent:  make(map[common.Address]*uint256.Int),
-		cache:  make(map[common.Hash]*blobTxMeta),
 	}
 }
 

core/txpool/legacypool/legacypool.go

@@ -508,19 +508,11 @@ func (pool *LegacyPool) ContentFrom(addr common.Address) ([]*types.Transaction,
 // The enforceTips parameter can be used to do an extra filtering on the pending
 // transactions and only return those whose **effective** tip is large enough in
 // the next pending execution environment.
-<<<<<<< HEAD
 func (pool *LegacyPool) Pending(enforceTips bool) map[common.Address][]*txpool.LazyTransaction {
 	pool.mu.Lock()
 	defer pool.mu.Unlock()
 
 	pending := make(map[common.Address][]*txpool.LazyTransaction, len(pool.pending))
-=======
-func (pool *LegacyPool) Pending(enforceTips bool) map[common.Address][]*txpool.Transaction {
-	pool.mu.Lock()
-	defer pool.mu.Unlock()
-
-	pending := make(map[common.Address][]*txpool.Transaction, len(pool.pending))
->>>>>>> ceafc2a1d (core, eth, miner: do integration with miner, todo clean up)
 	for addr, list := range pool.pending {
 		txs := list.Flatten()
 

eth/handler.go

@@ -67,11 +67,7 @@ type txPool interface {
 
 	// Pending should return pending transactions.
 	// The slice should be modifiable by the caller.
-<<<<<<< HEAD
 	Pending(enforceTips bool) map[common.Address][]*txpool.LazyTransaction
-=======
-	Pending(enforceTips bool) map[common.Address][]*txpool.Transaction
->>>>>>> ceafc2a1d (core, eth, miner: do integration with miner, todo clean up)
 
 	// SubscribeNewTxsEvent should return an event subscription of
 	// NewTxsEvent and send events to the given channel.

eth/handler_test.go

@@ -100,24 +100,18 @@ func (p *testTxPool) Add(txs []*txpool.Transaction, local bool, sync bool) []err
 	return make([]error, len(unwrapped))
 }
 
-type TxByNonce []*txpool.Transaction
-
-func (s TxByNonce) Len() int           { return len(s) }
-func (s TxByNonce) Less(i, j int) bool { return s[i].Tx.Nonce() < s[j].Tx.Nonce() }
-func (s TxByNonce) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-
 // Pending returns all the transactions known to the pool
 func (p *testTxPool) Pending(enforceTips bool) map[common.Address][]*txpool.LazyTransaction {
 	p.lock.RLock()
 	defer p.lock.RUnlock()
 
-	batches := make(map[common.Address][]*txpool.Transaction)
+	batches := make(map[common.Address][]*types.Transaction)
 	for _, tx := range p.pool {
 		from, _ := types.Sender(types.HomesteadSigner{}, tx)
-		batches[from] = append(batches[from], &txpool.Transaction{Tx: tx})
+		batches[from] = append(batches[from], tx)
 	}
 	for _, batch := range batches {
-		sort.Sort(TxByNonce(batch))
+		sort.Sort(types.TxByNonce(batch))
 	}
 	pending := make(map[common.Address][]*txpool.LazyTransaction)
 	for addr, batch := range batches {

miner/worker.go

@@ -760,7 +760,7 @@ func (w *worker) commitTransaction(env *environment, tx *txpool.Transaction) ([]
 		gp   = env.gasPool.Gas()
 	)
 	// TODO (MariusVanDerWijden): Move this check
-	if len(env.blobs)+len(tx.BlobHashes())*params.BlobTxDataGasPerBlob > params.BlobTxMaxDataGasPerBlock {
+	if len(env.blobs)+len(tx.Tx.BlobHashes())*params.BlobTxDataGasPerBlob > params.BlobTxMaxDataGasPerBlock {
 		return nil, errors.New("max data blobs reached")
 	}
 	receipt, err := core.ApplyTransaction(w.chainConfig, w.chain, &env.coinbase, env.gasPool, env.state, env.header, tx.Tx, &env.header.GasUsed, *w.chain.GetVMConfig())
@@ -833,8 +833,8 @@ func (w *worker) commitTransactions(env *environment, txs *transactionsByPriceAn
 			coalescedLogs = append(coalescedLogs, logs...)
 			env.tcount++
 			txs.Shift()
-			if tx.Type() == types.BlobTxType {
-				txWrap := w.eth.TxPool().Get(tx.Hash())
+			if tx.Tx.Type() == types.BlobTxType {
+				txWrap := w.eth.TxPool().Get(tx.Tx.Hash())
 				env.blobs = append(env.blobs, txWrap.BlobTxBlobs...)
 				env.commitments = append(env.commitments, txWrap.BlobTxCommits...)
 				env.proofs = append(env.proofs, txWrap.BlobTxProofs...)
@@ -964,16 +964,10 @@ func (w *worker) fillTransactions(interrupt *atomic.Int32, env *environment) err
 		if txs := pending[account]; len(txs) > 0 {
 			delete(pending, account)
 			for _, tx := range txs {
-				localTxs[account] = append(localTxs[account], tx.Tx)
+				localTxs[account] = append(localTxs[account], tx)
 			}
 		}
 	}
-	for account, remotes := range pending {
-		remoteTxs[account] = make([]*types.Transaction, 0, len(remotes))
-		for _, tx := range remotes {
-			remoteTxs[account] = append(remoteTxs[account], tx.Tx)
-		}
-	}
 
 	if len(localTxs) > 0 {
 		txs := newTransactionsByPriceAndNonce(env.signer, localTxs, env.header.BaseFee)