plugeth/ethchain/transaction_pool.go

225 lines
5.1 KiB
Go
Raw Normal View History

2014-02-14 22:56:09 +00:00
package ethchain
import (
"bytes"
"container/list"
"fmt"
"math/big"
"sync"
"github.com/ethereum/eth-go/ethlog"
2014-07-24 10:04:15 +00:00
"github.com/ethereum/eth-go/ethstate"
2014-06-26 17:45:57 +00:00
"github.com/ethereum/eth-go/ethwire"
2014-02-14 22:56:09 +00:00
)
var txplogger = ethlog.NewLogger("TXP")
2014-02-14 22:56:09 +00:00
const (
txPoolQueueSize = 50
)
type TxPoolHook chan *Transaction
2014-02-25 10:22:27 +00:00
type TxMsgTy byte
const (
TxPre = iota
TxPost
minGasPrice = 1000000
2014-02-25 10:22:27 +00:00
)
var MinGasPrice = big.NewInt(10000000000000)
2014-02-25 10:22:27 +00:00
type TxMsg struct {
Tx *Transaction
Type TxMsgTy
}
2014-02-14 22:56:09 +00:00
func FindTx(pool *list.List, finder func(*Transaction, *list.Element) bool) *Transaction {
for e := pool.Front(); e != nil; e = e.Next() {
if tx, ok := e.Value.(*Transaction); ok {
if finder(tx, e) {
return tx
}
}
}
return nil
}
2014-02-23 00:57:04 +00:00
type TxProcessor interface {
ProcessTransaction(tx *Transaction)
}
2014-02-14 22:56:09 +00:00
// The tx pool a thread safe transaction pool handler. In order to
// guarantee a non blocking pool we use a queue channel which can be
// independently read without needing access to the actual pool. If the
// pool is being drained or synced for whatever reason the transactions
// will simple queue up and handled when the mutex is freed.
type TxPool struct {
Ethereum EthManager
2014-02-14 22:56:09 +00:00
// The mutex for accessing the Tx pool.
mutex sync.Mutex
// Queueing channel for reading and writing incoming
// transactions to
queueChan chan *Transaction
// Quiting channel
quit chan bool
// The actual pool
pool *list.List
2014-02-23 00:57:04 +00:00
SecondaryProcessor TxProcessor
2014-02-25 10:22:27 +00:00
subscribers []chan TxMsg
2014-02-14 22:56:09 +00:00
}
func NewTxPool(ethereum EthManager) *TxPool {
2014-02-14 22:56:09 +00:00
return &TxPool{
pool: list.New(),
queueChan: make(chan *Transaction, txPoolQueueSize),
quit: make(chan bool),
Ethereum: ethereum,
2014-02-14 22:56:09 +00:00
}
}
// Blocking function. Don't use directly. Use QueueTransaction instead
func (pool *TxPool) addTransaction(tx *Transaction) {
pool.mutex.Lock()
2014-05-21 10:38:56 +00:00
defer pool.mutex.Unlock()
2014-02-14 22:56:09 +00:00
pool.pool.PushBack(tx)
// Broadcast the transaction to the rest of the peers
pool.Ethereum.Broadcast(ethwire.MsgTxTy, []interface{}{tx.RlpData()})
2014-02-14 22:56:09 +00:00
}
func (pool *TxPool) ValidateTransaction(tx *Transaction) error {
// Get the last block so we can retrieve the sender and receiver from
// the merkle trie
block := pool.Ethereum.BlockChain().CurrentBlock
2014-02-14 22:56:09 +00:00
// Something has gone horribly wrong if this happens
if block == nil {
return fmt.Errorf("[TXPL] No last block on the block chain")
2014-02-14 22:56:09 +00:00
}
if len(tx.Recipient) != 0 && len(tx.Recipient) != 20 {
2014-06-12 08:07:27 +00:00
return fmt.Errorf("[TXPL] Invalid recipient. len = %d", len(tx.Recipient))
}
2014-09-23 16:19:51 +00:00
if tx.GasPrice.Cmp(MinGasPrice) < 0 {
return fmt.Errorf("Gas price to low. Require %v > Got %v", MinGasPrice, tx.GasPrice)
}
2014-02-14 22:56:09 +00:00
// Get the sender
//sender := pool.Ethereum.StateManager().procState.GetAccount(tx.Sender())
sender := pool.Ethereum.StateManager().CurrentState().GetAccount(tx.Sender())
2014-02-14 22:56:09 +00:00
2014-06-16 09:13:19 +00:00
totAmount := new(big.Int).Set(tx.Value)
2014-02-14 22:56:09 +00:00
// Make sure there's enough in the sender's account. Having insufficient
// funds won't invalidate this transaction but simple ignores it.
if sender.Balance.Cmp(totAmount) < 0 {
2014-03-20 10:20:29 +00:00
return fmt.Errorf("[TXPL] Insufficient amount in sender's (%x) account", tx.Sender())
2014-02-14 22:56:09 +00:00
}
if tx.IsContract() {
if tx.GasPrice.Cmp(big.NewInt(minGasPrice)) < 0 {
return fmt.Errorf("[TXPL] Gasprice too low, %s given should be at least %d.", tx.GasPrice, minGasPrice)
}
}
2014-02-14 22:56:09 +00:00
// Increment the nonce making each tx valid only once to prevent replay
// attacks
return nil
}
func (pool *TxPool) queueHandler() {
out:
for {
select {
case tx := <-pool.queueChan:
hash := tx.Hash()
foundTx := FindTx(pool.pool, func(tx *Transaction, e *list.Element) bool {
return bytes.Compare(tx.Hash(), hash) == 0
})
if foundTx != nil {
break
}
// Validate the transaction
err := pool.ValidateTransaction(tx)
if err != nil {
txplogger.Debugln("Validating Tx failed", err)
2014-02-14 22:56:09 +00:00
} else {
2014-04-30 15:13:32 +00:00
// Call blocking version.
2014-02-14 22:56:09 +00:00
pool.addTransaction(tx)
2014-03-10 10:53:02 +00:00
tmp := make([]byte, 4)
copy(tmp, tx.Recipient)
txplogger.Debugf("(t) %x => %x (%v) %x\n", tx.Sender()[:4], tmp, tx.Value, tx.Hash())
2014-06-12 08:07:27 +00:00
2014-03-10 10:53:02 +00:00
// Notify the subscribers
pool.Ethereum.EventMux().Post(TxEvent{TxPre, tx})
2014-02-14 22:56:09 +00:00
}
case <-pool.quit:
break out
}
}
}
func (pool *TxPool) QueueTransaction(tx *Transaction) {
pool.queueChan <- tx
}
func (pool *TxPool) CurrentTransactions() []*Transaction {
2014-02-14 22:56:09 +00:00
pool.mutex.Lock()
defer pool.mutex.Unlock()
txList := make([]*Transaction, pool.pool.Len())
i := 0
for e := pool.pool.Front(); e != nil; e = e.Next() {
tx := e.Value.(*Transaction)
txList[i] = tx
2014-02-14 22:56:09 +00:00
i++
}
return txList
}
2014-07-24 10:04:15 +00:00
func (pool *TxPool) RemoveInvalid(state *ethstate.State) {
for e := pool.pool.Front(); e != nil; e = e.Next() {
tx := e.Value.(*Transaction)
sender := state.GetAccount(tx.Sender())
err := pool.ValidateTransaction(tx)
2014-05-28 13:07:11 +00:00
if err != nil || sender.Nonce >= tx.Nonce {
pool.pool.Remove(e)
}
}
}
func (pool *TxPool) Flush() []*Transaction {
txList := pool.CurrentTransactions()
2014-02-14 22:56:09 +00:00
// Recreate a new list all together
// XXX Is this the fastest way?
pool.pool = list.New()
return txList
}
func (pool *TxPool) Start() {
go pool.queueHandler()
}
func (pool *TxPool) Stop() {
close(pool.quit)
pool.Flush()
2014-03-17 09:33:03 +00:00
txplogger.Infoln("Stopped")
2014-02-14 22:56:09 +00:00
}