Merge branch 'develop' of https://github.com/ethereum/go-ethereum into develop

10 files changed, 199 insertions, 91 deletions

diff --git a/core/block_processor.go b/core/block_processor.go
index 893c586dd..7eaeb5be0 100644
--- a/core/block_processor.go
+++ b/core/block_processor.go
@@ -48,9 +48,8 @@ type BlockProcessor struct {
 
 func NewBlockProcessor(db ethutil.Database, txpool *TxPool, chainManager *ChainManager, eventMux *event.TypeMux) *BlockProcessor {
 	sm := &BlockProcessor{
-		db:  db,
-		mem: make(map[string]*big.Int),
-		//Pow:      &ethash.Ethash{},
+		db:       db,
+		mem:      make(map[string]*big.Int),
 		Pow:      ezp.New(),
 		bc:       chainManager,
 		eventMux: eventMux,
@@ -60,12 +59,12 @@ func NewBlockProcessor(db ethutil.Database, txpool *TxPool, chainManager *ChainM
 	return sm
 }
 
-func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block *types.Block) (receipts types.Receipts, err error) {
+func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block *types.Block, transientProcess bool) (receipts types.Receipts, err error) {
 	coinbase := statedb.GetOrNewStateObject(block.Header().Coinbase)
-	coinbase.SetGasPool(CalcGasLimit(parent, block))
+	coinbase.SetGasPool(block.Header().GasLimit)
 
 	// Process the transactions on to parent state
-	receipts, _, _, _, err = sm.ApplyTransactions(coinbase, statedb, block, block.Transactions(), false)
+	receipts, _, _, _, err = sm.ApplyTransactions(coinbase, statedb, block, block.Transactions(), transientProcess)
 	if err != nil {
 		return nil, err
 	}
@@ -73,38 +72,41 @@ func (sm *BlockProcessor) TransitionState(statedb *state.StateDB, parent, block
 	return receipts, nil
 }
 
-func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, state *state.StateDB, block *types.Block, tx *types.Transaction, usedGas *big.Int, transientProcess bool) (*types.Receipt, *big.Int, error) {
+func (self *BlockProcessor) ApplyTransaction(coinbase *state.StateObject, statedb *state.StateDB, block *types.Block, tx *types.Transaction, usedGas *big.Int, transientProcess bool) (*types.Receipt, *big.Int, error) {
 	// If we are mining this block and validating we want to set the logs back to 0
-	state.EmptyLogs()
+	statedb.EmptyLogs()
 
 	txGas := new(big.Int).Set(tx.Gas())
 
-	cb := state.GetStateObject(coinbase.Address())
-	st := NewStateTransition(NewEnv(state, self.bc, tx, block), tx, cb)
+	cb := statedb.GetStateObject(coinbase.Address())
+	st := NewStateTransition(NewEnv(statedb, self.bc, tx, block), tx, cb)
 	_, err := st.TransitionState()
+	if err != nil && (IsNonceErr(err) || state.IsGasLimitErr(err)) {
+		return nil, nil, err
+	}
 
 	txGas.Sub(txGas, st.gas)
 
 	// Update the state with pending changes
-	state.Update(txGas)
+	statedb.Update(txGas)
 
 	cumulative := new(big.Int).Set(usedGas.Add(usedGas, txGas))
-	receipt := types.NewReceipt(state.Root(), cumulative)
-	receipt.SetLogs(state.Logs())
+	receipt := types.NewReceipt(statedb.Root(), cumulative)
+	receipt.SetLogs(statedb.Logs())
 	receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
 	chainlogger.Debugln(receipt)
 
 	// Notify all subscribers
 	if !transientProcess {
 		go self.eventMux.Post(TxPostEvent{tx})
+		logs := statedb.Logs()
+		go self.eventMux.Post(logs)
 	}
 
-	go self.eventMux.Post(state.Logs())
-
 	return receipt, txGas, err
 }
 
-func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, state *state.StateDB, block *types.Block, txs types.Transactions, transientProcess bool) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, error) {
+func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, statedb *state.StateDB, block *types.Block, txs types.Transactions, transientProcess bool) (types.Receipts, types.Transactions, types.Transactions, types.Transactions, error) {
 	var (
 		receipts           types.Receipts
 		handled, unhandled types.Transactions
@@ -115,12 +117,12 @@ func (self *BlockProcessor) ApplyTransactions(coinbase *state.StateObject, state
 	)
 
 	for _, tx := range txs {
-		receipt, txGas, err := self.ApplyTransaction(coinbase, state, block, tx, totalUsedGas, transientProcess)
+		receipt, txGas, err := self.ApplyTransaction(coinbase, statedb, block, tx, totalUsedGas, transientProcess)
 		if err != nil {
 			switch {
 			case IsNonceErr(err):
 				return nil, nil, nil, nil, err
-			case IsGasLimitErr(err):
+			case state.IsGasLimitErr(err):
 				return nil, nil, nil, nil, err
 			default:
 				statelogger.Infoln(err)
@@ -176,7 +178,7 @@ func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (td *big
 		return
 	}
 
-	receipts, err := sm.TransitionState(state, parent, block)
+	receipts, err := sm.TransitionState(state, parent, block, false)
 	if err != nil {
 		return
 	}
@@ -245,12 +247,21 @@ func (sm *BlockProcessor) ValidateBlock(block, parent *types.Block) error {
 		return fmt.Errorf("Difficulty check failed for block %v, %v", block.Header().Difficulty, expd)
 	}
 
+	expl := CalcGasLimit(parent, block)
+	if expl.Cmp(block.Header().GasLimit) != 0 {
+		return fmt.Errorf("GasLimit check failed for block %v, %v", block.Header().GasLimit, expl)
+	}
+
 	if block.Time() < parent.Time() {
 		return ValidationError("Block timestamp not after prev block (%v - %v)", block.Header().Time, parent.Header().Time)
 	}
 
 	if block.Time() > time.Now().Unix() {
-		return fmt.Errorf("block time is in the future")
+		return BlockFutureErr
+	}
+
+	if new(big.Int).Sub(block.Number(), parent.Number()).Cmp(big.NewInt(1)) != 0 {
+		return BlockNumberErr
 	}
 
 	// Verify the nonce of the block. Return an error if it's not valid
@@ -289,16 +300,13 @@ func (sm *BlockProcessor) AccumulateRewards(statedb *state.StateDB, block, paren
 		r := new(big.Int)
 		r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16))
 
-		uncleAccount := statedb.GetAccount(uncle.Coinbase)
-		uncleAccount.AddAmount(r)
+		statedb.AddBalance(uncle.Coinbase, r)
 
 		reward.Add(reward, new(big.Int).Div(BlockReward, big.NewInt(32)))
 	}
 
 	// Get the account associated with the coinbase
-	account := statedb.GetAccount(block.Header().Coinbase)
-	// Reward amount of ether to the coinbase address
-	account.AddAmount(reward)
+	statedb.AddBalance(block.Header().Coinbase, reward)
 
 	return nil
 }
@@ -312,13 +320,10 @@ func (sm *BlockProcessor) GetLogs(block *types.Block) (logs state.Logs, err erro
 
 	var (
 		parent = sm.bc.GetBlock(block.Header().ParentHash)
-		//state  = state.New(parent.Trie().Copy())
-		state = state.New(parent.Root(), sm.db)
+		state  = state.New(parent.Root(), sm.db)
 	)
 
-	defer state.Reset()
-
-	sm.TransitionState(state, parent, block)
+	sm.TransitionState(state, parent, block, true)
 	sm.AccumulateRewards(state, block, parent)
 
 	return state.Logs(), nil
diff --git a/core/block_processor_test.go b/core/block_processor_test.go
new file mode 100644
index 000000000..35aeaa714
--- /dev/null
+++ b/core/block_processor_test.go
@@ -0,0 +1,34 @@
+package core
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+func proc() (*BlockProcessor, *ChainManager) {
+	db, _ := ethdb.NewMemDatabase()
+	var mux event.TypeMux
+
+	chainMan := NewChainManager(db, &mux)
+	return NewBlockProcessor(db, nil, chainMan, &mux), chainMan
+}
+
+func TestNumber(t *testing.T) {
+	bp, chain := proc()
+	block1 := chain.NewBlock(nil)
+	block1.Header().Number = big.NewInt(3)
+
+	err := bp.ValidateBlock(block1, chain.Genesis())
+	if err != BlockNumberErr {
+		t.Errorf("expected block number error")
+	}
+
+	block1 = chain.NewBlock(nil)
+	err = bp.ValidateBlock(block1, chain.Genesis())
+	if err == BlockNumberErr {
+		t.Errorf("didn't expect block number error")
+	}
+}
diff --git a/core/chain_manager.go b/core/chain_manager.go
index 22d54be03..959bfd398 100644
--- a/core/chain_manager.go
+++ b/core/chain_manager.go
@@ -85,6 +85,16 @@ type ChainManager struct {
 	lastBlockHash []byte
 
 	transState *state.StateDB
+	txState    *state.StateDB
+}
+
+func NewChainManager(db ethutil.Database, mux *event.TypeMux) *ChainManager {
+	bc := &ChainManager{db: db, genesisBlock: GenesisBlock(db), eventMux: mux}
+	bc.setLastBlock()
+	bc.transState = bc.State().Copy()
+	bc.txState = bc.State().Copy()
+
+	return bc
 }
 
 func (self *ChainManager) Td() *big.Int {
@@ -108,14 +118,6 @@ func (self *ChainManager) CurrentBlock() *types.Block {
 	return self.currentBlock
 }
 
-func NewChainManager(db ethutil.Database, mux *event.TypeMux) *ChainManager {
-	bc := &ChainManager{db: db, genesisBlock: GenesisBlock(db), eventMux: mux}
-	bc.setLastBlock()
-	bc.transState = bc.State().Copy()
-
-	return bc
-}
-
 func (self *ChainManager) Status() (td *big.Int, currentBlock []byte, genesisBlock []byte) {
 	self.mu.RLock()
 	defer self.mu.RUnlock()
@@ -134,14 +136,24 @@ func (self *ChainManager) State() *state.StateDB {
 func (self *ChainManager) TransState() *state.StateDB {
 	self.tsmu.RLock()
 	defer self.tsmu.RUnlock()
-	//tmp := self.transState
 
 	return self.transState
 }
 
-func (self *ChainManager) setTransState(statedb *state.StateDB) {
+func (self *ChainManager) TxState() *state.StateDB {
+	self.tsmu.RLock()
+	defer self.tsmu.RUnlock()
+
+	return self.txState
+}
+
+func (self *ChainManager) setTxState(state *state.StateDB) {
 	self.tsmu.Lock()
 	defer self.tsmu.Unlock()
+	self.txState = state
+}
+
+func (self *ChainManager) setTransState(statedb *state.StateDB) {
 	self.transState = statedb
 }
 
@@ -361,7 +373,12 @@ func (bc *ChainManager) Stop() {
 }
 
 func (self *ChainManager) InsertChain(chain types.Blocks) error {
+	self.tsmu.Lock()
+	defer self.tsmu.Unlock()
+
 	for _, block := range chain {
+		// Call in to the block processor and check for errors. It's likely that if one block fails
+		// all others will fail too (unless a known block is returned).
 		td, err := self.processor.Process(block)
 		if err != nil {
 			if IsKnownBlockErr(err) {
@@ -376,23 +393,38 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error {
 		}
 		block.Td = td
 
+		var canonical, split bool
 		self.mu.Lock()
 		{
+			// Write block to database. Eventually we'll have to improve on this and throw away blocks that are
+			// not in the canonical chain.
 			self.write(block)
 			cblock := self.currentBlock
+			// Compare the TD of the last known block in the canonical chain to make sure it's greater.
+			// At this point it's possible that a different chain (fork) becomes the new canonical chain.
 			if td.Cmp(self.td) > 0 {
 				if block.Header().Number.Cmp(new(big.Int).Add(cblock.Header().Number, ethutil.Big1)) < 0 {
 					chainlogger.Infof("Split detected. New head #%v (%x) TD=%v, was #%v (%x) TD=%v\n", block.Header().Number, block.Hash()[:4], td, cblock.Header().Number, cblock.Hash()[:4], self.td)
+					split = true
 				}
 
 				self.setTotalDifficulty(td)
 				self.insert(block)
-				self.setTransState(state.New(cblock.Root(), self.db))
 
-				self.eventMux.Post(ChainEvent{block, td})
+				canonical = true
 			}
 		}
 		self.mu.Unlock()
+
+		if canonical {
+			self.setTransState(state.New(block.Root(), self.db))
+			self.eventMux.Post(ChainEvent{block, td})
+		}
+
+		if split {
+			self.setTxState(state.New(block.Root(), self.db))
+			self.eventMux.Post(ChainSplitEvent{block})
+		}
 	}
 
 	return nil
diff --git a/core/error.go b/core/error.go
index 11d8c1653..e86bacb2d 100644
--- a/core/error.go
+++ b/core/error.go
@@ -1,10 +1,16 @@
 package core
 
 import (
+	"errors"
 	"fmt"
 	"math/big"
 )
 
+var (
+	BlockNumberErr = errors.New("block number invalid")
+	BlockFutureErr = errors.New("block time is in the future")
+)
+
 // Parent error. In case a parent is unknown this error will be thrown
 // by the block manager
 type ParentErr struct {
@@ -62,23 +68,6 @@ func IsValidationErr(err error) bool {
 	return ok
 }
 
-type GasLimitErr struct {
-	Message string
-	Is, Max *big.Int
-}
-
-func IsGasLimitErr(err error) bool {
-	_, ok := err.(*GasLimitErr)
-
-	return ok
-}
-func (err *GasLimitErr) Error() string {
-	return err.Message
-}
-func GasLimitError(is, max *big.Int) *GasLimitErr {
-	return &GasLimitErr{Message: fmt.Sprintf("GasLimit error. Max %s, transaction would take it to %s", max, is), Is: is, Max: max}
-}
-
 type NonceErr struct {
 	Message string
 	Is, Exp uint64
diff --git a/core/events.go b/core/events.go
index fe106da49..4cbbc609c 100644
--- a/core/events.go
+++ b/core/events.go
@@ -13,3 +13,6 @@ type NewBlockEvent struct{ Block *types.Block }
 
 // NewMinedBlockEvent is posted when a block has been imported.
 type NewMinedBlockEvent struct{ Block *types.Block }
+
+// ChainSplit is posted when a new head is detected
+type ChainSplitEvent struct{ Block *types.Block }
diff --git a/core/filter.go b/core/filter.go
index 88f12a67c..cdf7b282d 100644
--- a/core/filter.go
+++ b/core/filter.go
@@ -111,14 +111,14 @@ func (self *Filter) Find() state.Logs {
 		// current parameters
 		if self.bloomFilter(block) {
 			// Get the logs of the block
-			logs, err := self.eth.BlockProcessor().GetLogs(block)
+			unfiltered, err := self.eth.BlockProcessor().GetLogs(block)
 			if err != nil {
 				chainlogger.Warnln("err: filter get logs ", err)
 
 				break
 			}
 
-			logs = append(logs, self.FilterLogs(logs)...)
+			logs = append(logs, self.FilterLogs(unfiltered)...)
 		}
 
 		block = self.eth.ChainManager().GetBlock(block.ParentHash())
@@ -146,7 +146,6 @@ func (self *Filter) FilterLogs(logs state.Logs) state.Logs {
 Logs:
 	for _, log := range logs {
 		if !includes(self.address, log.Address()) {
-			//if !bytes.Equal(self.address, log.Address()) {
 			continue
 		}
 
diff --git a/core/genesis.go b/core/genesis.go
index c870ce61e..75b4fc100 100644
--- a/core/genesis.go
+++ b/core/genesis.go
@@ -1,7 +1,10 @@
 package core
 
 import (
+	"encoding/json"
+	"fmt"
 	"math/big"
+	"os"
 
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -31,24 +34,39 @@ func GenesisBlock(db ethutil.Database) *types.Block {
 	genesis.SetTransactions(types.Transactions{})
 	genesis.SetReceipts(types.Receipts{})
 
+	var accounts map[string]struct{ Balance string }
+	err := json.Unmarshal(genesisData, &accounts)
+	if err != nil {
+		fmt.Println("enable to decode genesis json data:", err)
+		os.Exit(1)
+	}
+
 	statedb := state.New(genesis.Root(), db)
-	for _, addr := range []string{
-		"dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6",
-		"e4157b34ea9615cfbde6b4fda419828124b70c78",
-		"b9c015918bdaba24b4ff057a92a3873d6eb201be",
-		"6c386a4b26f73c802f34673f7248bb118f97424a",
-		"cd2a3d9f938e13cd947ec05abc7fe734df8dd826",
-		"2ef47100e0787b915105fd5e3f4ff6752079d5cb",
-		"e6716f9544a56c530d868e4bfbacb172315bdead",
-		"1a26338f0d905e295fccb71fa9ea849ffa12aaf4",
-	} {
+	for addr, account := range accounts {
 		codedAddr := ethutil.Hex2Bytes(addr)
-		account := statedb.GetAccount(codedAddr)
-		account.SetBalance(ethutil.Big("1606938044258990275541962092341162602522202993782792835301376")) //ethutil.BigPow(2, 200)
-		statedb.UpdateStateObject(account)
+		accountState := statedb.GetAccount(codedAddr)
+		accountState.SetBalance(ethutil.Big(account.Balance))
+		statedb.UpdateStateObject(accountState)
 	}
 	statedb.Sync()
 	genesis.Header().Root = statedb.Root()
 
+	fmt.Printf("+++ genesis +++\nRoot: %x\nHash: %x\n", genesis.Header().Root, genesis.Hash())
+
 	return genesis
 }
+
+var genesisData = []byte(`{
+	"dbdbdb2cbd23b783741e8d7fcf51e459b497e4a6": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"e4157b34ea9615cfbde6b4fda419828124b70c78": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"b9c015918bdaba24b4ff057a92a3873d6eb201be": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"6c386a4b26f73c802f34673f7248bb118f97424a": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"cd2a3d9f938e13cd947ec05abc7fe734df8dd826": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"2ef47100e0787b915105fd5e3f4ff6752079d5cb": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"e6716f9544a56c530d868e4bfbacb172315bdead": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"1a26338f0d905e295fccb71fa9ea849ffa12aaf4": {"balance": "1606938044258990275541962092341162602522202993782792835301376"},
+	"b0afc46d9ce366d06ab4952ca27db1d9557ae9fd": {"balance": "154162184000000000000000"},
+	"f6b1e9dc460d4d62cc22ec5f987d726929c0f9f0": {"balance": "102774789000000000000000"},
+	"cc45122d8b7fa0b1eaa6b29e0fb561422a9239d0": {"balance": "51387394000000000000000"},
+	"b7576e9d314df41ec5506494293afb1bd5d3f65d": {"balance": "69423399000000000000000"}
+}`)
diff --git a/core/state_transition.go b/core/state_transition.go
index 33dd45f02..7331fdd4a 100644
--- a/core/state_transition.go
+++ b/core/state_transition.go
@@ -126,7 +126,7 @@ func (self *StateTransition) BuyGas() error {
 
 	self.AddGas(self.msg.Gas())
 	self.initialGas.Set(self.msg.Gas())
-	sender.SubAmount(MessageGasValue(self.msg))
+	sender.SubBalance(MessageGasValue(self.msg))
 
 	return nil
 }
@@ -138,8 +138,8 @@ func (self *StateTransition) preCheck() (err error) {
 	)
 
 	// Make sure this transaction's nonce is correct
-	if sender.Nonce != msg.Nonce() {
-		return NonceError(msg.Nonce(), sender.Nonce)
+	if sender.Nonce() != msg.Nonce() {
+		return NonceError(msg.Nonce(), sender.Nonce())
 	}
 
 	// Pre-pay gas / Buy gas of the coinbase account
@@ -166,7 +166,8 @@ func (self *StateTransition) TransitionState() (ret []byte, err error) {
 	defer self.RefundGas()
 
 	// Increment the nonce for the next transaction
-	sender.Nonce += 1
+	self.state.SetNonce(sender.Address(), sender.Nonce()+1)
+	//sender.Nonce += 1
 
 	// Transaction gas
 	if err = self.UseGas(vm.GasTx); err != nil {
@@ -241,7 +242,7 @@ func MakeContract(msg Message, state *state.StateDB) *state.StateObject {
 	addr := AddressFromMessage(msg)
 
 	contract := state.GetOrNewStateObject(addr)
-	contract.InitCode = msg.Data()
+	contract.SetInitCode(msg.Data())
 
 	return contract
 }
@@ -250,7 +251,7 @@ func (self *StateTransition) RefundGas() {
 	coinbase, sender := self.Coinbase(), self.From()
 	// Return remaining gas
 	remaining := new(big.Int).Mul(self.gas, self.msg.GasPrice())
-	sender.AddAmount(remaining)
+	sender.AddBalance(remaining)
 
 	uhalf := new(big.Int).Div(self.GasUsed(), ethutil.Big2)
 	for addr, ref := range self.state.Refunds() {
diff --git a/core/transaction_pool.go b/core/transaction_pool.go
index c617e6cb6..860f57dc3 100644
--- a/core/transaction_pool.go
+++ b/core/transaction_pool.go
@@ -3,6 +3,7 @@ package core
 import (
 	"errors"
 	"fmt"
+	"sync"
 
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethutil"
@@ -35,6 +36,7 @@ type TxProcessor interface {
 // guarantee a non blocking pool we use a queue channel which can be
 // independently read without needing access to the actual pool.
 type TxPool struct {
+	mu sync.RWMutex
 	// Queueing channel for reading and writing incoming
 	// transactions to
 	queueChan chan *types.Transaction
@@ -97,7 +99,7 @@ func (self *TxPool) addTx(tx *types.Transaction) {
 	self.txs[string(tx.Hash())] = tx
 }
 
-func (self *TxPool) Add(tx *types.Transaction) error {
+func (self *TxPool) add(tx *types.Transaction) error {
 	if self.txs[string(tx.Hash())] != nil {
 		return fmt.Errorf("Known transaction (%x)", tx.Hash()[0:4])
 	}
@@ -133,17 +135,28 @@ func (self *TxPool) Size() int {
 	return len(self.txs)
 }
 
+func (self *TxPool) Add(tx *types.Transaction) error {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+	return self.add(tx)
+}
 func (self *TxPool) AddTransactions(txs []*types.Transaction) {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+
 	for _, tx := range txs {
-		if err := self.Add(tx); err != nil {
-			txplogger.Infoln(err)
+		if err := self.add(tx); err != nil {
+			txplogger.Debugln(err)
 		} else {
-			txplogger.Infof("tx %x\n", tx.Hash()[0:4])
+			txplogger.Debugf("tx %x\n", tx.Hash()[0:4])
 		}
 	}
 }
 
 func (self *TxPool) GetTransactions() (txs types.Transactions) {
+	self.mu.RLock()
+	defer self.mu.RUnlock()
+
 	txs = make(types.Transactions, self.Size())
 	i := 0
 	for _, tx := range self.txs {
@@ -155,30 +168,32 @@ func (self *TxPool) GetTransactions() (txs types.Transactions) {
 }
 
 func (pool *TxPool) RemoveInvalid(query StateQuery) {
+	pool.mu.Lock()
+
 	var removedTxs types.Transactions
 	for _, tx := range pool.txs {
 		sender := query.GetAccount(tx.From())
 		err := pool.ValidateTransaction(tx)
-		fmt.Println(err, sender.Nonce, tx.Nonce())
-		if err != nil || sender.Nonce >= tx.Nonce() {
+		if err != nil || sender.Nonce() >= tx.Nonce() {
 			removedTxs = append(removedTxs, tx)
 		}
 	}
+	pool.mu.Unlock()
 
 	pool.RemoveSet(removedTxs)
 }
 
 func (self *TxPool) RemoveSet(txs types.Transactions) {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+
 	for _, tx := range txs {
 		delete(self.txs, string(tx.Hash()))
 	}
 }
 
-func (pool *TxPool) Flush() []*types.Transaction {
-	txList := pool.GetTransactions()
+func (pool *TxPool) Flush() {
 	pool.txs = make(map[string]*types.Transaction)
-
-	return txList
 }
 
 func (pool *TxPool) Start() {
diff --git a/core/types/block.go b/core/types/block.go
index fa28f5cc7..d57de1311 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -185,6 +185,18 @@ func (self *Block) GasUsed() *big.Int         { return self.header.GasUsed }
 func (self *Block) Root() []byte              { return self.header.Root }
 func (self *Block) SetRoot(root []byte)       { self.header.Root = root }
 func (self *Block) Size() ethutil.StorageSize { return ethutil.StorageSize(len(ethutil.Encode(self))) }
+func (self *Block) GetTransaction(i int) *Transaction {
+	if len(self.transactions) > i {
+		return self.transactions[i]
+	}
+	return nil
+}
+func (self *Block) GetUncle(i int) *Header {
+	if len(self.uncles) > i {
+		return self.uncles[i]
+	}
+	return nil
+}
 
 // Implement pow.Block
 func (self *Block) Difficulty() *big.Int { return self.header.Difficulty }