From 9b7990888e99261dfaf00131abf708d5c2c167b7 Mon Sep 17 00:00:00 2001 From: Jacky Wang Date: Tue, 13 Apr 2021 20:50:13 -0700 Subject: [PATCH] [txpool] reverted some txpool code --- core/tx_list.go | 37 +++++++++++-------------------------- core/tx_pool.go | 17 ++++++++--------- 2 files changed, 19 insertions(+), 35 deletions(-) diff --git a/core/tx_list.go b/core/tx_list.go index 2d368612d..eb1685b1d 100644 --- a/core/tx_list.go +++ b/core/tx_list.go @@ -22,12 +22,9 @@ import ( "math/big" "sort" - "github.com/pkg/errors" - "github.com/ethereum/go-ethereum/common" "github.com/harmony-one/harmony/core/types" "github.com/harmony-one/harmony/internal/utils" - staking "github.com/harmony-one/harmony/staking/types" ) // nonceHeap is a heap.Interface implementation over 64bit unsigned integers for @@ -315,38 +312,26 @@ func (l *txList) Forward(threshold uint64) types.PoolTransactions { return l.txs.Forward(threshold) } -// FilterValid returns all regular transactions from the list with a cost or gas limit higher +// FilterPrice returns all regular transactions from the list with a cost or gas limit higher // than the provided thresholds and all staking transactions that can not be validated. -func (l *txList) FilterValid( +func (l *txList) FilterPrice( txPool *TxPool, address common.Address, -) (types.PoolTransactions, types.PoolTransactions, []error) { +) (types.PoolTransactions, types.PoolTransactions) { costLimit := txPool.currentState.GetBalance(address) gasLimit := txPool.currentMaxGas // If all transactions are below the threshold, short circuit if l.costcap.Cmp(costLimit) <= 0 && l.gascap <= gasLimit { - return nil, nil, nil + return nil, nil } l.costcap = new(big.Int).Set(costLimit) // Lower the caps to the thresholds l.gascap = gasLimit - return l.Filter(func(tx types.PoolTransaction) error { + return l.Filter(func(tx types.PoolTransaction) bool { cost, err := tx.Cost() if err != nil { - return err // failure should lead to removal of the tx - } - if cost.Cmp(costLimit) > 0 { - return errors.New("not enough balance") - } - if tx.GasLimit() > gasLimit { - return errors.New("transaction gas limit exceeding block limit") + return true // failure should lead to removal of the tx } - if _, ok := tx.(*staking.StakingTransaction); ok { - err := txPool.validateTx(tx, false) - if err != nil { - return err - } - } - return nil + return cost.Cmp(costLimit) == 1 || tx.GasLimit() > gasLimit }) } @@ -354,13 +339,13 @@ func (l *txList) FilterValid( // the specified function evaluates to true. Moreover, it returns all transactions // that were invalidated from the filter func (l *txList) Filter( - filter func(types.PoolTransaction) error, -) (types.PoolTransactions, types.PoolTransactions, []error) { + filter func(types.PoolTransaction) bool, +) (types.PoolTransactions, types.PoolTransactions) { // If the list was strict, filter anything above the lowest nonce var invalids types.PoolTransactions // Filter out all the transactions above the account's funds - removed, errs := l.txs.FilterWithError(filter) + removed := l.txs.Filter(filter) if l.strict && len(removed) > 0 { lowest := uint64(math.MaxUint64) for _, tx := range removed { @@ -370,7 +355,7 @@ func (l *txList) Filter( } invalids = l.txs.Filter(func(tx types.PoolTransaction) bool { return tx.Nonce() > lowest }) } - return removed, invalids, errs + return removed, invalids } // Cap places a hard limit on the number of items, returning all transactions diff --git a/core/tx_pool.go b/core/tx_pool.go index 31bd43411..3bc79b668 100644 --- a/core/tx_pool.go +++ b/core/tx_pool.go @@ -1315,14 +1315,14 @@ func (pool *TxPool) promoteExecutables(accounts []common.Address) { // Do not report to error sink as old txs are on chain or meaningful error caught elsewhere. } // Drop all transactions that are too costly (low balance or out of gas) - drops, _, errs := list.FilterValid(pool, addr) - for i, tx := range drops { + drops, _ := list.FilterPrice(pool, addr) + for _, tx := range drops { hash := tx.Hash() pool.all.Remove(hash) pool.priced.Removed() queuedNofundsCounter.Inc(1) - pool.txErrorSink.Add(tx, errs[i]) - logger.Warn().Str("hash", hash.Hex()).Err(errs[i]).Msg("Removed unpayable queued transaction") + pool.txErrorSink.Add(tx, fmt.Errorf("removed unpayable queued transaction")) + logger.Warn().Str("hash", hash.Hex()).Msg("Removed unpayable queued transaction") } // Gather all executable transactions and promote them for _, tx := range list.Ready(pool.pendingState.GetNonce(addr)) { @@ -1488,15 +1488,14 @@ func (pool *TxPool) demoteUnexecutables() { // Do not report to error sink as old txs are on chain or meaningful error caught elsewhere. } // Drop all transactions that are too costly (low balance or out of gas), and queue any invalids back for later - drops, invalids, errs := list.FilterValid(pool, addr) - for i, tx := range drops { + drops, invalids := list.FilterPrice(pool, addr) + for _, tx := range drops { hash := tx.Hash() pool.all.Remove(hash) pool.priced.Removed() pendingNofundsCounter.Inc(1) - pool.txErrorSink.Add(tx, errs[i]) - logger.Warn().Str("hash", hash.Hex()).Err(errs[i]). - Msg("Removed unexecutable pending transaction") + pool.txErrorSink.Add(tx, fmt.Errorf("removed unexecutable pending transaction")) + logger.Warn().Str("hash", hash.Hex()).Msg("Removed unexecutable pending transaction") } for _, tx := range invalids { hash := tx.Hash()