2015-07-07 00:54:22 +00:00
|
|
|
// Copyright 2014 The go-ethereum Authors
|
2015-07-22 16:48:40 +00:00
|
|
|
// This file is part of the go-ethereum library.
|
2015-07-07 00:54:22 +00:00
|
|
|
//
|
2015-07-23 16:35:11 +00:00
|
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
2015-07-07 00:54:22 +00:00
|
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
//
|
2015-07-22 16:48:40 +00:00
|
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
2015-07-07 00:54:22 +00:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
2015-07-22 16:48:40 +00:00
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2015-07-07 00:54:22 +00:00
|
|
|
// GNU Lesser General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
2015-07-22 16:48:40 +00:00
|
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
2015-07-07 00:54:22 +00:00
|
|
|
|
2014-12-04 09:28:02 +00:00
|
|
|
package core
|
2014-02-14 22:56:09 +00:00
|
|
|
|
|
|
|
import (
|
2015-01-31 16:22:17 +00:00
|
|
|
"errors"
|
2014-02-14 22:56:09 +00:00
|
|
|
"fmt"
|
2015-04-08 18:47:32 +00:00
|
|
|
"math/big"
|
2015-02-19 21:33:22 +00:00
|
|
|
"sync"
|
2015-11-20 23:40:36 +00:00
|
|
|
"time"
|
2014-07-29 22:31:15 +00:00
|
|
|
|
2015-03-16 10:27:38 +00:00
|
|
|
"github.com/ethereum/go-ethereum/common"
|
2015-04-08 18:47:32 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/state"
|
2015-03-17 10:59:26 +00:00
|
|
|
"github.com/ethereum/go-ethereum/core/types"
|
2014-12-18 12:12:54 +00:00
|
|
|
"github.com/ethereum/go-ethereum/event"
|
2014-10-31 11:56:05 +00:00
|
|
|
"github.com/ethereum/go-ethereum/logger"
|
2015-04-08 18:47:32 +00:00
|
|
|
"github.com/ethereum/go-ethereum/logger/glog"
|
2014-02-14 22:56:09 +00:00
|
|
|
)
|
|
|
|
|
2015-01-31 16:22:17 +00:00
|
|
|
var (
|
2015-06-03 13:23:31 +00:00
|
|
|
// Transaction Pool Errors
|
2015-04-08 18:47:32 +00:00
|
|
|
ErrInvalidSender = errors.New("Invalid sender")
|
2015-04-21 20:01:04 +00:00
|
|
|
ErrNonce = errors.New("Nonce too low")
|
2015-06-15 09:33:08 +00:00
|
|
|
ErrCheap = errors.New("Gas price too low for acceptance")
|
2015-04-26 09:19:40 +00:00
|
|
|
ErrBalance = errors.New("Insufficient balance")
|
2015-05-10 23:28:15 +00:00
|
|
|
ErrNonExistentAccount = errors.New("Account does not exist or account balance too low")
|
2015-04-26 09:19:40 +00:00
|
|
|
ErrInsufficientFunds = errors.New("Insufficient funds for gas * price + value")
|
2015-04-08 18:47:32 +00:00
|
|
|
ErrIntrinsicGas = errors.New("Intrinsic gas too low")
|
2015-04-24 15:45:51 +00:00
|
|
|
ErrGasLimit = errors.New("Exceeds block gas limit")
|
2015-05-26 17:50:42 +00:00
|
|
|
ErrNegativeValue = errors.New("Negative value")
|
2015-01-31 16:22:17 +00:00
|
|
|
)
|
2014-06-23 11:54:10 +00:00
|
|
|
|
2015-06-15 10:16:29 +00:00
|
|
|
const (
|
2015-06-30 09:04:30 +00:00
|
|
|
maxQueued = 64 // max limit of queued txs per address
|
2015-06-15 10:16:29 +00:00
|
|
|
)
|
|
|
|
|
2015-10-06 14:35:55 +00:00
|
|
|
type stateFn func() (*state.StateDB, error)
|
2015-04-21 09:27:12 +00:00
|
|
|
|
2015-06-03 13:23:31 +00:00
|
|
|
// TxPool contains all currently known transactions. Transactions
|
|
|
|
// enter the pool when they are received from the network or submitted
|
|
|
|
// locally. They exit the pool when they are included in the blockchain.
|
|
|
|
//
|
|
|
|
// The pool separates processable transactions (which can be applied to the
|
|
|
|
// current state) and future transactions. Transactions move between those
|
|
|
|
// two states over time as they are received and processed.
|
2014-02-14 22:56:09 +00:00
|
|
|
type TxPool struct {
|
2016-03-01 22:32:43 +00:00
|
|
|
config *ChainConfig
|
2016-03-29 01:08:16 +00:00
|
|
|
currentState stateFn // The state function which will allow us to do some pre checks
|
2015-06-09 16:14:46 +00:00
|
|
|
pendingState *state.ManagedState
|
2015-06-03 12:20:44 +00:00
|
|
|
gasLimit func() *big.Int // The current gas limit function callback
|
2015-06-15 09:33:08 +00:00
|
|
|
minGasPrice *big.Int
|
2015-06-03 12:20:44 +00:00
|
|
|
eventMux *event.TypeMux
|
2015-06-03 20:22:20 +00:00
|
|
|
events event.Subscription
|
2015-11-20 23:40:36 +00:00
|
|
|
localTx *txSet
|
|
|
|
mu sync.RWMutex
|
2016-06-27 15:28:34 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
pending map[common.Address]*txList // All currently processable transactions
|
|
|
|
queue map[common.Address]*txList // Queued but non-processable transactions
|
2016-06-27 15:28:34 +00:00
|
|
|
all map[common.Hash]*types.Transaction // All transactions to allow lookups
|
2016-01-19 22:50:00 +00:00
|
|
|
|
2016-03-29 01:08:16 +00:00
|
|
|
wg sync.WaitGroup // for shutdown sync
|
|
|
|
|
2016-01-19 22:50:00 +00:00
|
|
|
homestead bool
|
2014-02-14 22:56:09 +00:00
|
|
|
}
|
|
|
|
|
2016-03-01 22:32:43 +00:00
|
|
|
func NewTxPool(config *ChainConfig, eventMux *event.TypeMux, currentStateFn stateFn, gasLimitFn func() *big.Int) *TxPool {
|
2015-06-09 21:46:56 +00:00
|
|
|
pool := &TxPool{
|
2016-03-01 22:32:43 +00:00
|
|
|
config: config,
|
2016-07-01 15:59:55 +00:00
|
|
|
pending: make(map[common.Address]*txList),
|
|
|
|
queue: make(map[common.Address]*txList),
|
2016-06-27 15:28:34 +00:00
|
|
|
all: make(map[common.Hash]*types.Transaction),
|
2015-06-03 12:20:44 +00:00
|
|
|
eventMux: eventMux,
|
|
|
|
currentState: currentStateFn,
|
|
|
|
gasLimit: gasLimitFn,
|
2015-06-15 09:33:08 +00:00
|
|
|
minGasPrice: new(big.Int),
|
2015-10-06 14:35:55 +00:00
|
|
|
pendingState: nil,
|
2015-11-20 23:40:36 +00:00
|
|
|
localTx: newTxSet(),
|
2015-08-17 12:01:41 +00:00
|
|
|
events: eventMux.Subscribe(ChainHeadEvent{}, GasPriceChanged{}, RemovedTransactionEvent{}),
|
2014-02-14 22:56:09 +00:00
|
|
|
}
|
2016-01-19 22:50:00 +00:00
|
|
|
|
2016-03-29 01:08:16 +00:00
|
|
|
pool.wg.Add(1)
|
2015-06-09 21:46:56 +00:00
|
|
|
go pool.eventLoop()
|
|
|
|
|
|
|
|
return pool
|
2015-04-21 20:01:04 +00:00
|
|
|
}
|
|
|
|
|
2015-06-09 21:46:56 +00:00
|
|
|
func (pool *TxPool) eventLoop() {
|
2016-03-29 01:08:16 +00:00
|
|
|
defer pool.wg.Done()
|
|
|
|
|
2015-06-04 14:19:22 +00:00
|
|
|
// Track chain events. When a chain events occurs (new chain canon block)
|
|
|
|
// we need to know the new state. The new state will help us determine
|
|
|
|
// the nonces in the managed state
|
2015-06-15 09:33:08 +00:00
|
|
|
for ev := range pool.events.Chan() {
|
2015-10-12 12:04:38 +00:00
|
|
|
switch ev := ev.Data.(type) {
|
2015-06-30 13:42:20 +00:00
|
|
|
case ChainHeadEvent:
|
2015-08-17 12:01:41 +00:00
|
|
|
pool.mu.Lock()
|
2016-03-01 22:32:43 +00:00
|
|
|
if ev.Block != nil && pool.config.IsHomestead(ev.Block.Number()) {
|
2016-01-19 22:50:00 +00:00
|
|
|
pool.homestead = true
|
|
|
|
}
|
|
|
|
|
2015-06-15 09:33:08 +00:00
|
|
|
pool.resetState()
|
2015-08-17 12:01:41 +00:00
|
|
|
pool.mu.Unlock()
|
2015-06-15 09:33:08 +00:00
|
|
|
case GasPriceChanged:
|
2015-08-17 12:01:41 +00:00
|
|
|
pool.mu.Lock()
|
2015-06-15 09:33:08 +00:00
|
|
|
pool.minGasPrice = ev.Price
|
2015-08-17 12:01:41 +00:00
|
|
|
pool.mu.Unlock()
|
|
|
|
case RemovedTransactionEvent:
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.AddBatch(ev.Txs)
|
2015-06-15 09:33:08 +00:00
|
|
|
}
|
2015-04-21 20:01:04 +00:00
|
|
|
}
|
2014-02-14 22:56:09 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 15:28:09 +00:00
|
|
|
func (pool *TxPool) resetState() {
|
2015-10-06 14:35:55 +00:00
|
|
|
currentState, err := pool.currentState()
|
|
|
|
if err != nil {
|
2016-07-01 15:59:55 +00:00
|
|
|
glog.V(logger.Error).Infof("Failed to get current state: %v", err)
|
2015-10-06 14:35:55 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
managedState := state.ManageState(currentState)
|
|
|
|
if err != nil {
|
2016-07-01 15:59:55 +00:00
|
|
|
glog.V(logger.Error).Infof("Failed to get managed state: %v", err)
|
2015-10-06 14:35:55 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
pool.pendingState = managedState
|
2015-06-04 15:28:09 +00:00
|
|
|
|
|
|
|
// validate the pool of pending transactions, this will remove
|
|
|
|
// any transactions that have been included in the block or
|
|
|
|
// have been invalidated because of another transaction (e.g.
|
|
|
|
// higher gas price)
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.demoteUnexecutables()
|
|
|
|
|
|
|
|
// Update all accounts to the latest known pending nonce
|
|
|
|
for addr, list := range pool.pending {
|
|
|
|
pool.pendingState.SetNonce(addr, list.last+1)
|
2015-06-04 15:28:09 +00:00
|
|
|
}
|
|
|
|
// Check the queue and move transactions over to the pending if possible
|
|
|
|
// or remove those that have become invalid
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.promoteExecutables()
|
2015-06-04 15:28:09 +00:00
|
|
|
}
|
|
|
|
|
2015-06-03 20:22:20 +00:00
|
|
|
func (pool *TxPool) Stop() {
|
|
|
|
pool.events.Unsubscribe()
|
2016-03-29 01:08:16 +00:00
|
|
|
pool.wg.Wait()
|
2015-08-01 15:34:48 +00:00
|
|
|
glog.V(logger.Info).Infoln("Transaction pool stopped")
|
2015-06-03 20:22:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (pool *TxPool) State() *state.ManagedState {
|
|
|
|
pool.mu.RLock()
|
|
|
|
defer pool.mu.RUnlock()
|
|
|
|
|
2015-06-09 16:14:46 +00:00
|
|
|
return pool.pendingState
|
2015-06-03 20:22:20 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Stats retrieves the current pool stats, namely the number of pending and the
|
|
|
|
// number of queued (non-executable) transactions.
|
2015-06-30 09:04:30 +00:00
|
|
|
func (pool *TxPool) Stats() (pending int, queued int) {
|
|
|
|
pool.mu.RLock()
|
|
|
|
defer pool.mu.RUnlock()
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
for _, list := range pool.pending {
|
|
|
|
pending += list.Len()
|
2016-06-27 15:28:34 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
for _, list := range pool.queue {
|
|
|
|
queued += list.Len()
|
2015-06-30 09:04:30 +00:00
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2015-12-30 11:32:15 +00:00
|
|
|
// Content retrieves the data content of the transaction pool, returning all the
|
2016-07-01 15:59:55 +00:00
|
|
|
// pending as well as queued transactions, grouped by account and sorted by nonce.
|
|
|
|
func (pool *TxPool) Content() (map[common.Address]types.Transactions, map[common.Address]types.Transactions) {
|
2015-12-30 11:32:15 +00:00
|
|
|
pool.mu.RLock()
|
|
|
|
defer pool.mu.RUnlock()
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
pending := make(map[common.Address]types.Transactions)
|
|
|
|
for addr, list := range pool.pending {
|
|
|
|
pending[addr] = list.Flatten()
|
|
|
|
}
|
|
|
|
queued := make(map[common.Address]types.Transactions)
|
|
|
|
for addr, list := range pool.queue {
|
|
|
|
queued[addr] = list.Flatten()
|
2015-12-30 11:32:15 +00:00
|
|
|
}
|
|
|
|
return pending, queued
|
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Pending retrieves all currently processable transactions, groupped by origin
|
|
|
|
// account and sorted by nonce. The returned transaction set is a copy and can be
|
|
|
|
// freely modified by calling code.
|
|
|
|
func (pool *TxPool) Pending() map[common.Address]types.Transactions {
|
|
|
|
pool.mu.Lock()
|
|
|
|
defer pool.mu.Unlock()
|
|
|
|
|
|
|
|
// check queue first
|
|
|
|
pool.promoteExecutables()
|
|
|
|
|
|
|
|
// invalidate any txs
|
|
|
|
pool.demoteUnexecutables()
|
|
|
|
|
|
|
|
pending := make(map[common.Address]types.Transactions)
|
|
|
|
for addr, list := range pool.pending {
|
|
|
|
pending[addr] = list.Flatten()
|
|
|
|
}
|
|
|
|
return pending
|
|
|
|
}
|
|
|
|
|
2015-11-20 23:40:36 +00:00
|
|
|
// SetLocal marks a transaction as local, skipping gas price
|
|
|
|
// check against local miner minimum in the future
|
|
|
|
func (pool *TxPool) SetLocal(tx *types.Transaction) {
|
|
|
|
pool.mu.Lock()
|
|
|
|
defer pool.mu.Unlock()
|
|
|
|
pool.localTx.add(tx.Hash())
|
|
|
|
}
|
|
|
|
|
2015-06-03 13:23:31 +00:00
|
|
|
// validateTx checks whether a transaction is valid according
|
|
|
|
// to the consensus rules.
|
|
|
|
func (pool *TxPool) validateTx(tx *types.Transaction) error {
|
2015-11-20 23:40:36 +00:00
|
|
|
local := pool.localTx.contains(tx.Hash())
|
2015-06-15 09:33:08 +00:00
|
|
|
// Drop transactions under our own minimal accepted gas price
|
2015-11-20 23:40:36 +00:00
|
|
|
if !local && pool.minGasPrice.Cmp(tx.GasPrice()) > 0 {
|
2015-06-15 09:33:08 +00:00
|
|
|
return ErrCheap
|
|
|
|
}
|
|
|
|
|
2015-11-27 14:40:29 +00:00
|
|
|
currentState, err := pool.currentState()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2016-01-19 22:50:00 +00:00
|
|
|
from, err := tx.From()
|
2015-11-27 14:40:29 +00:00
|
|
|
if err != nil {
|
2015-03-18 12:38:47 +00:00
|
|
|
return ErrInvalidSender
|
2014-12-01 23:14:34 +00:00
|
|
|
}
|
2015-04-08 18:47:32 +00:00
|
|
|
|
2015-06-17 14:22:35 +00:00
|
|
|
// Make sure the account exist. Non existent accounts
|
2015-06-04 14:19:22 +00:00
|
|
|
// haven't got funds and well therefor never pass.
|
2015-10-06 14:35:55 +00:00
|
|
|
if !currentState.HasAccount(from) {
|
2015-04-08 18:47:32 +00:00
|
|
|
return ErrNonExistentAccount
|
2014-06-10 13:02:41 +00:00
|
|
|
}
|
2015-04-08 18:47:32 +00:00
|
|
|
|
2015-06-17 15:09:39 +00:00
|
|
|
// Last but not least check for nonce errors
|
2015-10-06 14:35:55 +00:00
|
|
|
if currentState.GetNonce(from) > tx.Nonce() {
|
2015-06-17 15:09:39 +00:00
|
|
|
return ErrNonce
|
|
|
|
}
|
|
|
|
|
2015-06-04 14:19:22 +00:00
|
|
|
// Check the transaction doesn't exceed the current
|
|
|
|
// block limit gas.
|
2015-06-11 12:05:32 +00:00
|
|
|
if pool.gasLimit().Cmp(tx.Gas()) < 0 {
|
2015-04-24 15:45:51 +00:00
|
|
|
return ErrGasLimit
|
|
|
|
}
|
|
|
|
|
2015-06-04 14:19:22 +00:00
|
|
|
// Transactions can't be negative. This may never happen
|
|
|
|
// using RLP decoded transactions but may occur if you create
|
|
|
|
// a transaction using the RPC for example.
|
2015-06-11 12:05:32 +00:00
|
|
|
if tx.Value().Cmp(common.Big0) < 0 {
|
2015-05-26 17:50:42 +00:00
|
|
|
return ErrNegativeValue
|
|
|
|
}
|
|
|
|
|
2015-06-04 14:19:22 +00:00
|
|
|
// Transactor should have enough funds to cover the costs
|
|
|
|
// cost == V + GP * GL
|
2015-10-06 14:35:55 +00:00
|
|
|
if currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {
|
2015-04-08 18:47:32 +00:00
|
|
|
return ErrInsufficientFunds
|
|
|
|
}
|
|
|
|
|
2016-01-19 22:50:00 +00:00
|
|
|
intrGas := IntrinsicGas(tx.Data(), MessageCreatesContract(tx), pool.homestead)
|
2015-11-27 14:40:29 +00:00
|
|
|
if tx.Gas().Cmp(intrGas) < 0 {
|
2015-04-08 18:47:32 +00:00
|
|
|
return ErrIntrinsicGas
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
2014-02-14 22:56:09 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// add validates a transaction and inserts it into the non-executable queue for
|
|
|
|
// later pending promotion and execution.
|
|
|
|
func (pool *TxPool) add(tx *types.Transaction) error {
|
|
|
|
// If the transaction is alreayd known, discard it
|
2015-03-17 11:16:21 +00:00
|
|
|
hash := tx.Hash()
|
2016-07-01 15:59:55 +00:00
|
|
|
if pool.all[hash] != nil {
|
|
|
|
return fmt.Errorf("Known transaction: %x", hash[:4])
|
2015-01-07 00:21:45 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Otherwise ensure basic validation passes nd queue it up
|
|
|
|
if err := pool.validateTx(tx); err != nil {
|
2014-12-01 19:18:09 +00:00
|
|
|
return err
|
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.enqueueTx(hash, tx)
|
2015-04-08 18:47:32 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Print a log message if low enough level is set
|
2015-04-08 18:47:32 +00:00
|
|
|
if glog.V(logger.Debug) {
|
2016-07-01 15:59:55 +00:00
|
|
|
rcpt := "[NEW_CONTRACT]"
|
2015-06-03 12:06:20 +00:00
|
|
|
if to := tx.To(); to != nil {
|
2016-07-01 15:59:55 +00:00
|
|
|
rcpt = common.Bytes2Hex(to[:4])
|
2015-06-03 12:06:20 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
from, _ := tx.From() // from already verified during tx validation
|
|
|
|
glog.Infof("(t) 0x%x => %s (%v) %x\n", from[:4], rcpt, tx.Value, hash)
|
2015-04-08 18:47:32 +00:00
|
|
|
}
|
2014-12-01 19:18:09 +00:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// enqueueTx inserts a new transction into the non-executable transaction queue.
|
|
|
|
//
|
|
|
|
// Note, this method assumes the pool lock is held!
|
|
|
|
func (pool *TxPool) enqueueTx(hash common.Hash, tx *types.Transaction) {
|
|
|
|
// Try to insert the transaction into the future queue
|
|
|
|
from, _ := tx.From() // already validated
|
|
|
|
if pool.queue[from] == nil {
|
|
|
|
pool.queue[from] = newTxList(false)
|
2015-06-09 21:46:56 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
inserted, old := pool.queue[from].Add(tx)
|
|
|
|
if !inserted {
|
|
|
|
return // An older transaction was better, discard this
|
|
|
|
}
|
|
|
|
// Discard any previous transaction and mark this
|
|
|
|
if old != nil {
|
|
|
|
delete(pool.all, old.Hash())
|
2016-06-27 15:28:34 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.all[hash] = tx
|
2015-06-09 21:46:56 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// promoteTx adds a transaction to the pending (processable) list of transactions.
|
|
|
|
//
|
|
|
|
// Note, this method assumes the pool lock is held!
|
|
|
|
func (pool *TxPool) promoteTx(addr common.Address, hash common.Hash, tx *types.Transaction) {
|
2016-06-27 15:28:34 +00:00
|
|
|
// Init delayed since tx pool could have been started before any state sync
|
2015-10-06 14:35:55 +00:00
|
|
|
if pool.pendingState == nil {
|
|
|
|
pool.resetState()
|
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Try to insert the transaction into the pending queue
|
|
|
|
if pool.pending[addr] == nil {
|
|
|
|
pool.pending[addr] = newTxList(true)
|
|
|
|
}
|
|
|
|
list := pool.pending[addr]
|
2015-06-09 21:46:56 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
inserted, old := list.Add(tx)
|
|
|
|
if !inserted {
|
|
|
|
// An older transaction was better, discard this
|
|
|
|
delete(pool.all, hash)
|
|
|
|
return
|
2016-06-27 15:28:34 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Otherwise discard any previous transaction and mark this
|
|
|
|
if old != nil {
|
|
|
|
delete(pool.all, old.Hash())
|
2015-06-09 21:46:56 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.all[hash] = tx // Failsafe to work around direct pending inserts (tests)
|
2016-06-27 15:28:34 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Set the potentially new pending nonce and notify any subsystems of the new tx
|
|
|
|
pool.pendingState.SetNonce(addr, list.last+1)
|
2016-06-27 15:28:34 +00:00
|
|
|
go pool.eventMux.Post(TxPreEvent{tx})
|
2015-06-09 21:46:56 +00:00
|
|
|
}
|
|
|
|
|
2015-06-03 13:23:31 +00:00
|
|
|
// Add queues a single transaction in the pool if it is valid.
|
2016-07-01 15:59:55 +00:00
|
|
|
func (pool *TxPool) Add(tx *types.Transaction) error {
|
|
|
|
pool.mu.Lock()
|
|
|
|
defer pool.mu.Unlock()
|
2015-04-07 22:31:23 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
if err := pool.add(tx); err != nil {
|
2015-12-30 16:31:37 +00:00
|
|
|
return err
|
2015-06-30 09:04:30 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.promoteExecutables()
|
|
|
|
|
2015-12-30 16:31:37 +00:00
|
|
|
return nil
|
2015-02-19 21:33:22 +00:00
|
|
|
}
|
2015-03-17 10:59:26 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// AddBatch attempts to queue a batch of transactions.
|
|
|
|
func (pool *TxPool) AddBatch(txs []*types.Transaction) {
|
|
|
|
pool.mu.Lock()
|
|
|
|
defer pool.mu.Unlock()
|
2015-02-19 21:33:22 +00:00
|
|
|
|
2014-12-14 18:15:48 +00:00
|
|
|
for _, tx := range txs {
|
2016-07-01 15:59:55 +00:00
|
|
|
if err := pool.add(tx); err != nil {
|
2015-04-26 09:19:40 +00:00
|
|
|
glog.V(logger.Debug).Infoln("tx error:", err)
|
2014-12-14 18:15:48 +00:00
|
|
|
}
|
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.promoteExecutables()
|
2014-12-14 18:15:48 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Get returns a transaction if it is contained in the pool
|
2015-06-03 13:23:31 +00:00
|
|
|
// and nil otherwise.
|
2016-07-01 15:59:55 +00:00
|
|
|
func (pool *TxPool) Get(hash common.Hash) *types.Transaction {
|
|
|
|
pool.mu.RLock()
|
|
|
|
defer pool.mu.RUnlock()
|
2015-02-19 21:33:22 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
return pool.all[hash]
|
2015-04-23 08:51:13 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Remove removes the transaction with the given hash from the pool.
|
|
|
|
func (pool *TxPool) Remove(hash common.Hash) {
|
|
|
|
pool.mu.Lock()
|
|
|
|
defer pool.mu.Unlock()
|
2016-06-27 15:28:34 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.removeTx(hash)
|
2014-10-27 15:52:58 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// RemoveBatch removes all given transactions from the pool.
|
|
|
|
func (pool *TxPool) RemoveBatch(txs types.Transactions) {
|
2016-06-02 18:33:45 +00:00
|
|
|
pool.mu.Lock()
|
|
|
|
defer pool.mu.Unlock()
|
2016-06-27 15:28:34 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
for _, tx := range txs {
|
|
|
|
pool.removeTx(tx.Hash())
|
|
|
|
}
|
2016-06-02 18:33:45 +00:00
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// removeTx iterates removes a single transaction from the queue, moving all
|
|
|
|
// subsequent transactions back to the future queue.
|
2016-06-02 18:33:45 +00:00
|
|
|
func (pool *TxPool) removeTx(hash common.Hash) {
|
2016-06-27 15:28:34 +00:00
|
|
|
// Fetch the transaction we wish to delete
|
|
|
|
tx, ok := pool.all[hash]
|
|
|
|
if !ok {
|
|
|
|
return
|
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
addr, _ := tx.From() // already validated during insertion
|
2016-06-27 15:28:34 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Remove it from the list of known transactions
|
2016-06-27 15:28:34 +00:00
|
|
|
delete(pool.all, hash)
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Remove the transaction from the pending lists and reset the account nonce
|
|
|
|
if pending := pool.pending[addr]; pending != nil {
|
|
|
|
if removed, invalids := pending.Remove(tx); removed {
|
|
|
|
// If no more transactions are left, remove the list and reset the nonce
|
|
|
|
if pending.Empty() {
|
|
|
|
delete(pool.pending, addr)
|
|
|
|
pool.pendingState.SetNonce(addr, tx.Nonce())
|
|
|
|
} else {
|
|
|
|
// Otherwise update the nonce and postpone any invalidated transactions
|
|
|
|
pool.pendingState.SetNonce(addr, pending.last)
|
|
|
|
for _, tx := range invalids {
|
|
|
|
pool.enqueueTx(tx.Hash(), tx)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-06-27 15:28:34 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Transaction is in the future queue
|
|
|
|
if future := pool.queue[addr]; future != nil {
|
|
|
|
future.Remove(tx)
|
|
|
|
if future.Empty() {
|
|
|
|
delete(pool.queue, addr)
|
|
|
|
}
|
2015-06-30 09:04:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// promoteExecutables moves transactions that have become processable from the
|
|
|
|
// future queue to the set of pending transactions. During this process, all
|
|
|
|
// invalidated transactions (low nonce, low balance) are deleted.
|
|
|
|
func (pool *TxPool) promoteExecutables() {
|
2016-06-27 15:28:34 +00:00
|
|
|
// Init delayed since tx pool could have been started before any state sync
|
2015-10-06 14:35:55 +00:00
|
|
|
if pool.pendingState == nil {
|
|
|
|
pool.resetState()
|
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Retrieve the current state to allow nonce and balance checking
|
|
|
|
state, err := pool.currentState()
|
|
|
|
if err != nil {
|
|
|
|
glog.Errorf("Could not get current state: %v", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// Iterate over all accounts and promote any executable transactions
|
|
|
|
for addr, list := range pool.queue {
|
|
|
|
// Drop all transactions that are deemed too old (low nonce)
|
|
|
|
for _, tx := range list.Forward(state.GetNonce(addr)) {
|
|
|
|
if glog.V(logger.Core) {
|
|
|
|
glog.Infof("Removed old queued transaction: %v", tx)
|
|
|
|
}
|
|
|
|
delete(pool.all, tx.Hash())
|
2015-10-06 14:35:55 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Drop all transactions that are too costly (low balance)
|
|
|
|
drops, _ := list.Filter(state.GetBalance(addr))
|
|
|
|
for _, tx := range drops {
|
|
|
|
if glog.V(logger.Core) {
|
|
|
|
glog.Infof("Removed unpayable queued transaction: %v", tx)
|
2015-06-15 14:46:45 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
delete(pool.all, tx.Hash())
|
2015-12-30 16:31:37 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Gather all executable transactions and promote them
|
|
|
|
for _, tx := range list.Ready(pool.pendingState.GetNonce(addr)) {
|
|
|
|
if glog.V(logger.Core) {
|
|
|
|
glog.Infof("Promoting queued transaction: %v", tx)
|
2015-04-21 20:01:04 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.promoteTx(addr, tx.Hash(), tx)
|
|
|
|
}
|
|
|
|
// Drop all transactions over the allowed limit
|
|
|
|
for _, tx := range list.Cap(maxQueued) {
|
|
|
|
if glog.V(logger.Core) {
|
|
|
|
glog.Infof("Removed cap-exceeding queued transaction: %v", tx)
|
2015-12-30 16:31:37 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
delete(pool.all, tx.Hash())
|
2015-04-21 20:01:04 +00:00
|
|
|
}
|
2015-06-03 12:06:20 +00:00
|
|
|
// Delete the entire queue entry if it became empty.
|
2016-07-01 15:59:55 +00:00
|
|
|
if list.Empty() {
|
|
|
|
delete(pool.queue, addr)
|
2015-04-21 20:01:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-04-23 09:09:58 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// demoteUnexecutables removes invalid and processed transactions from the pools
|
|
|
|
// executable/pending queue and any subsequent transactions that become unexecutable
|
|
|
|
// are moved back into the future queue.
|
|
|
|
func (pool *TxPool) demoteUnexecutables() {
|
|
|
|
// Retrieve the current state to allow nonce and balance checking
|
2015-10-06 14:35:55 +00:00
|
|
|
state, err := pool.currentState()
|
|
|
|
if err != nil {
|
|
|
|
glog.V(logger.Info).Infoln("failed to get current state: %v", err)
|
|
|
|
return
|
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
// Iterate over all accounts and demote any non-executable transactions
|
|
|
|
for addr, list := range pool.pending {
|
|
|
|
nonce := state.GetNonce(addr)
|
2015-12-30 16:31:37 +00:00
|
|
|
|
2016-07-01 15:59:55 +00:00
|
|
|
// Drop all transactions that are deemed too old (low nonce)
|
|
|
|
for _, tx := range list.Forward(nonce) {
|
|
|
|
if glog.V(logger.Core) {
|
|
|
|
glog.Infof("Removed old pending transaction: %v", tx)
|
2015-04-23 09:09:58 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
delete(pool.all, tx.Hash())
|
|
|
|
}
|
|
|
|
// Drop all transactions that are too costly (low balance), and queue any invalids back for later
|
|
|
|
drops, invalids := list.Filter(state.GetBalance(addr))
|
|
|
|
for _, tx := range drops {
|
|
|
|
if glog.V(logger.Core) {
|
|
|
|
glog.Infof("Removed unpayable pending transaction: %v", tx)
|
2015-12-30 16:31:37 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
delete(pool.all, tx.Hash())
|
2015-12-30 16:31:37 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
for _, tx := range invalids {
|
|
|
|
if glog.V(logger.Core) {
|
|
|
|
glog.Infof("Demoting pending transaction: %v", tx)
|
2015-12-30 16:31:37 +00:00
|
|
|
}
|
2016-07-01 15:59:55 +00:00
|
|
|
pool.enqueueTx(tx.Hash(), tx)
|
|
|
|
}
|
|
|
|
// Delete the entire queue entry if it became empty.
|
|
|
|
if list.Empty() {
|
|
|
|
delete(pool.pending, addr)
|
2015-04-23 09:09:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-06-03 12:06:20 +00:00
|
|
|
|
2015-11-20 23:40:36 +00:00
|
|
|
// txSet represents a set of transaction hashes in which entries
|
|
|
|
// are automatically dropped after txSetDuration time
|
|
|
|
type txSet struct {
|
|
|
|
txMap map[common.Hash]struct{}
|
|
|
|
txOrd map[uint64]txOrdType
|
|
|
|
addPtr, delPtr uint64
|
|
|
|
}
|
|
|
|
|
|
|
|
const txSetDuration = time.Hour * 2
|
|
|
|
|
|
|
|
// txOrdType represents an entry in the time-ordered list of transaction hashes
|
|
|
|
type txOrdType struct {
|
|
|
|
hash common.Hash
|
|
|
|
time time.Time
|
|
|
|
}
|
|
|
|
|
|
|
|
// newTxSet creates a new transaction set
|
|
|
|
func newTxSet() *txSet {
|
|
|
|
return &txSet{
|
|
|
|
txMap: make(map[common.Hash]struct{}),
|
|
|
|
txOrd: make(map[uint64]txOrdType),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// contains returns true if the set contains the given transaction hash
|
|
|
|
// (not thread safe, should be called from a locked environment)
|
|
|
|
func (self *txSet) contains(hash common.Hash) bool {
|
|
|
|
_, ok := self.txMap[hash]
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
// add adds a transaction hash to the set, then removes entries older than txSetDuration
|
|
|
|
// (not thread safe, should be called from a locked environment)
|
|
|
|
func (self *txSet) add(hash common.Hash) {
|
|
|
|
self.txMap[hash] = struct{}{}
|
|
|
|
now := time.Now()
|
|
|
|
self.txOrd[self.addPtr] = txOrdType{hash: hash, time: now}
|
|
|
|
self.addPtr++
|
|
|
|
delBefore := now.Add(-txSetDuration)
|
|
|
|
for self.delPtr < self.addPtr && self.txOrd[self.delPtr].time.Before(delBefore) {
|
|
|
|
delete(self.txMap, self.txOrd[self.delPtr].hash)
|
|
|
|
delete(self.txOrd, self.delPtr)
|
|
|
|
self.delPtr++
|
|
|
|
}
|
|
|
|
}
|