Merge branch 'develop'

4 files changed, 242 insertions, 163 deletions

diff --git a/miner/agent.go b/miner/agent.go
index 8455ed36e..2f8d9fee4 100644
--- a/miner/agent.go
+++ b/miner/agent.go
@@ -1,18 +1,18 @@
 // Copyright 2015 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
+// The go-ethereum library is free software: you can redistribute it and/or modify
 // 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
-// along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 package miner
 
@@ -20,7 +20,6 @@ import (
 	"sync"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/logger"
 	"github.com/ethereum/go-ethereum/logger/glog"
 	"github.com/ethereum/go-ethereum/pow"
@@ -29,10 +28,10 @@ import (
 type CpuAgent struct {
 	mu sync.Mutex
 
-	workCh        chan *types.Block
+	workCh        chan *Work
 	quit          chan struct{}
 	quitCurrentOp chan struct{}
-	returnCh      chan<- *types.Block
+	returnCh      chan<- *Result
 
 	index int
 	pow   pow.PoW
@@ -47,9 +46,9 @@ func NewCpuAgent(index int, pow pow.PoW) *CpuAgent {
 	return miner
 }
 
-func (self *CpuAgent) Work() chan<- *types.Block          { return self.workCh }
-func (self *CpuAgent) Pow() pow.PoW                       { return self.pow }
-func (self *CpuAgent) SetReturnCh(ch chan<- *types.Block) { self.returnCh = ch }
+func (self *CpuAgent) Work() chan<- *Work            { return self.workCh }
+func (self *CpuAgent) Pow() pow.PoW                  { return self.pow }
+func (self *CpuAgent) SetReturnCh(ch chan<- *Result) { self.returnCh = ch }
 
 func (self *CpuAgent) Stop() {
 	self.mu.Lock()
@@ -65,7 +64,7 @@ func (self *CpuAgent) Start() {
 	self.quit = make(chan struct{})
 	// creating current op ch makes sure we're not closing a nil ch
 	// later on
-	self.workCh = make(chan *types.Block, 1)
+	self.workCh = make(chan *Work, 1)
 
 	go self.update()
 }
@@ -74,13 +73,13 @@ func (self *CpuAgent) update() {
 out:
 	for {
 		select {
-		case block := <-self.workCh:
+		case work := <-self.workCh:
 			self.mu.Lock()
 			if self.quitCurrentOp != nil {
 				close(self.quitCurrentOp)
 			}
 			self.quitCurrentOp = make(chan struct{})
-			go self.mine(block, self.quitCurrentOp)
+			go self.mine(work, self.quitCurrentOp)
 			self.mu.Unlock()
 		case <-self.quit:
 			self.mu.Lock()
@@ -106,13 +105,14 @@ done:
 	}
 }
 
-func (self *CpuAgent) mine(block *types.Block, stop <-chan struct{}) {
+func (self *CpuAgent) mine(work *Work, stop <-chan struct{}) {
 	glog.V(logger.Debug).Infof("(re)started agent[%d]. mining...\n", self.index)
 
 	// Mine
-	nonce, mixDigest := self.pow.Search(block, stop)
+	nonce, mixDigest := self.pow.Search(work.Block, stop)
 	if nonce != 0 {
-		self.returnCh <- block.WithMiningResult(nonce, common.BytesToHash(mixDigest))
+		block := work.Block.WithMiningResult(nonce, common.BytesToHash(mixDigest))
+		self.returnCh <- &Result{work, block}
 	} else {
 		self.returnCh <- nil
 	}
diff --git a/miner/miner.go b/miner/miner.go
index 173be1a14..bf6a48802 100644
--- a/miner/miner.go
+++ b/miner/miner.go
@@ -1,18 +1,18 @@
 // Copyright 2014 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
+// The go-ethereum library is free software: you can redistribute it and/or modify
 // 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
-// along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 // Package miner implements Ethereum block creation and mining.
 package miner
diff --git a/miner/remote_agent.go b/miner/remote_agent.go
index b05d9c7e0..674ca40ac 100644
--- a/miner/remote_agent.go
+++ b/miner/remote_agent.go
@@ -1,56 +1,61 @@
 // Copyright 2015 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
+// The go-ethereum library is free software: you can redistribute it and/or modify
 // 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
-// along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 package miner
 
 import (
 	"math/big"
+	"sync"
+	"time"
 
 	"github.com/ethereum/ethash"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/logger"
+	"github.com/ethereum/go-ethereum/logger/glog"
 )
 
 type RemoteAgent struct {
-	work        *types.Block
-	currentWork *types.Block
+	mu sync.Mutex
 
 	quit     chan struct{}
-	workCh   chan *types.Block
-	returnCh chan<- *types.Block
+	workCh   chan *Work
+	returnCh chan<- *Result
+
+	currentWork *Work
+	work        map[common.Hash]*Work
 }
 
 func NewRemoteAgent() *RemoteAgent {
-	agent := &RemoteAgent{}
+	agent := &RemoteAgent{work: make(map[common.Hash]*Work)}
 
 	return agent
 }
 
-func (a *RemoteAgent) Work() chan<- *types.Block {
+func (a *RemoteAgent) Work() chan<- *Work {
 	return a.workCh
 }
 
-func (a *RemoteAgent) SetReturnCh(returnCh chan<- *types.Block) {
+func (a *RemoteAgent) SetReturnCh(returnCh chan<- *Result) {
 	a.returnCh = returnCh
 }
 
 func (a *RemoteAgent) Start() {
 	a.quit = make(chan struct{})
-	a.workCh = make(chan *types.Block, 1)
-	go a.run()
+	a.workCh = make(chan *Work, 1)
+	go a.maintainLoop()
 }
 
 func (a *RemoteAgent) Stop() {
@@ -60,47 +65,72 @@ func (a *RemoteAgent) Stop() {
 
 func (a *RemoteAgent) GetHashRate() int64 { return 0 }
 
-func (a *RemoteAgent) run() {
-out:
-	for {
-		select {
-		case <-a.quit:
-			break out
-		case work := <-a.workCh:
-			a.work = work
-		}
-	}
-}
-
 func (a *RemoteAgent) GetWork() [3]string {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
 	var res [3]string
 
-	if a.work != nil {
-		a.currentWork = a.work
+	if a.currentWork != nil {
+		block := a.currentWork.Block
 
-		res[0] = a.work.HashNoNonce().Hex()
-		seedHash, _ := ethash.GetSeedHash(a.currentWork.NumberU64())
+		res[0] = block.HashNoNonce().Hex()
+		seedHash, _ := ethash.GetSeedHash(block.NumberU64())
 		res[1] = common.BytesToHash(seedHash).Hex()
 		// Calculate the "target" to be returned to the external miner
 		n := big.NewInt(1)
 		n.Lsh(n, 255)
-		n.Div(n, a.work.Difficulty())
+		n.Div(n, block.Difficulty())
 		n.Lsh(n, 1)
 		res[2] = common.BytesToHash(n.Bytes()).Hex()
+
+		a.work[block.HashNoNonce()] = a.currentWork
 	}
 
 	return res
 }
 
-func (a *RemoteAgent) SubmitWork(nonce uint64, mixDigest, seedHash common.Hash) bool {
-	// Return true or false, but does not indicate if the PoW was correct
+// Returns true or false, but does not indicate if the PoW was correct
+func (a *RemoteAgent) SubmitWork(nonce uint64, mixDigest, hash common.Hash) bool {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	// Make sure the work submitted is present
+	if a.work[hash] != nil {
+		block := a.work[hash].Block.WithMiningResult(nonce, mixDigest)
+		a.returnCh <- &Result{a.work[hash], block}
+
+		delete(a.work, hash)
 
-	// Make sure the external miner was working on the right hash
-	if a.currentWork != nil && a.work != nil {
-		a.returnCh <- a.currentWork.WithMiningResult(nonce, mixDigest)
-		//a.returnCh <- Work{a.currentWork.Number().Uint64(), nonce, mixDigest.Bytes(), seedHash.Bytes()}
 		return true
+	} else {
+		glog.V(logger.Info).Infof("Work was submitted for %x but no pending work found\n", hash)
 	}
 
 	return false
 }
+
+func (a *RemoteAgent) maintainLoop() {
+	ticker := time.Tick(5 * time.Second)
+
+out:
+	for {
+		select {
+		case <-a.quit:
+			break out
+		case work := <-a.workCh:
+			a.mu.Lock()
+			a.currentWork = work
+			a.mu.Unlock()
+		case <-ticker:
+			// cleanup
+			a.mu.Lock()
+			for hash, work := range a.work {
+				if time.Since(work.createdAt) > 7*(12*time.Second) {
+					delete(a.work, hash)
+				}
+			}
+			a.mu.Unlock()
+		}
+	}
+}
diff --git a/miner/worker.go b/miner/worker.go
index 9f804bf30..535ce5144 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -1,18 +1,18 @@
 // Copyright 2015 The go-ethereum Authors
-// This file is part of go-ethereum.
+// This file is part of the go-ethereum library.
 //
-// go-ethereum is free software: you can redistribute it and/or modify
+// The go-ethereum library is free software: you can redistribute it and/or modify
 // 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.
 //
-// go-ethereum is distributed in the hope that it will be useful,
+// The go-ethereum library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 // GNU Lesser General Public License for more details.
 //
 // You should have received a copy of the GNU Lesser General Public License
-// along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
 package miner
 
@@ -38,25 +38,20 @@ import (
 
 var jsonlogger = logger.NewJsonLogger()
 
-// Work holds the current work
-type Work struct {
-	Number    uint64
-	Nonce     uint64
-	MixDigest []byte
-	SeedHash  []byte
-}
+const (
+	resultQueueSize  = 10
+	miningLogAtDepth = 5
+)
 
 // Agent can register themself with the worker
 type Agent interface {
-	Work() chan<- *types.Block
-	SetReturnCh(chan<- *types.Block)
+	Work() chan<- *Work
+	SetReturnCh(chan<- *Result)
 	Stop()
 	Start()
 	GetHashRate() int64
 }
 
-const miningLogAtDepth = 5
-
 type uint64RingBuffer struct {
 	ints []uint64 //array of all integers in buffer
 	next int      //where is the next insertion? assert 0 <= next < len(ints)
@@ -64,7 +59,7 @@ type uint64RingBuffer struct {
 
 // environment is the workers current environment and holds
 // all of the current state information
-type environment struct {
+type Work struct {
 	state              *state.StateDB     // apply state changes here
 	coinbase           *state.StateObject // the miner's account
 	ancestors          *set.Set           // ancestor set (used for checking uncle parent validity)
@@ -78,11 +73,18 @@ type environment struct {
 	lowGasTxs          types.Transactions
 	localMinedBlocks   *uint64RingBuffer // the most recent block numbers that were mined locally (used to check block inclusion)
 
-	block *types.Block // the new block
+	Block *types.Block // the new block
 
 	header   *types.Header
 	txs      []*types.Transaction
 	receipts []*types.Receipt
+
+	createdAt time.Time
+}
+
+type Result struct {
+	Work  *Work
+	Block *types.Block
 }
 
 // worker is the main object which takes care of applying messages to the new state
@@ -90,7 +92,7 @@ type worker struct {
 	mu sync.Mutex
 
 	agents []Agent
-	recv   chan *types.Block
+	recv   chan *Result
 	mux    *event.TypeMux
 	quit   chan struct{}
 	pow    pow.PoW
@@ -105,7 +107,7 @@ type worker struct {
 	extra    []byte
 
 	currentMu sync.Mutex
-	current   *environment
+	current   *Work
 
 	uncleMu        sync.Mutex
 	possibleUncles map[common.Hash]*types.Block
@@ -116,6 +118,8 @@ type worker struct {
 	// atomic status counters
 	mining int32
 	atWork int32
+
+	fullValidation bool
 }
 
 func newWorker(coinbase common.Address, eth core.Backend) *worker {
@@ -123,7 +127,7 @@ func newWorker(coinbase common.Address, eth core.Backend) *worker {
 		eth:            eth,
 		mux:            eth.EventMux(),
 		extraDb:        eth.ExtraDb(),
-		recv:           make(chan *types.Block),
+		recv:           make(chan *Result, resultQueueSize),
 		gasPrice:       new(big.Int),
 		chain:          eth.ChainManager(),
 		proc:           eth.BlockProcessor(),
@@ -131,6 +135,7 @@ func newWorker(coinbase common.Address, eth core.Backend) *worker {
 		coinbase:       coinbase,
 		txQueue:        make(map[common.Hash]*types.Transaction),
 		quit:           make(chan struct{}),
+		fullValidation: false,
 	}
 	go worker.update()
 	go worker.wait()
@@ -155,6 +160,7 @@ func (self *worker) pendingState() *state.StateDB {
 func (self *worker) pendingBlock() *types.Block {
 	self.currentMu.Lock()
 	defer self.currentMu.Unlock()
+
 	if atomic.LoadInt32(&self.mining) == 0 {
 		return types.NewBlock(
 			self.current.header,
@@ -163,7 +169,7 @@ func (self *worker) pendingBlock() *types.Block {
 			self.current.receipts,
 		)
 	}
-	return self.current.block
+	return self.current.Block
 }
 
 func (self *worker) start() {
@@ -223,9 +229,9 @@ out:
 			case core.TxPreEvent:
 				// Apply transaction to the pending state if we're not mining
 				if atomic.LoadInt32(&self.mining) == 0 {
-					self.mu.Lock()
+					self.currentMu.Lock()
 					self.current.commitTransactions(types.Transactions{ev.Tx}, self.gasPrice, self.proc)
-					self.mu.Unlock()
+					self.currentMu.Unlock()
 				}
 			}
 		case <-self.quit:
@@ -250,34 +256,55 @@ func newLocalMinedBlock(blockNumber uint64, prevMinedBlocks *uint64RingBuffer) (
 
 func (self *worker) wait() {
 	for {
-		for block := range self.recv {
+		for result := range self.recv {
 			atomic.AddInt32(&self.atWork, -1)
 
-			if block == nil {
+			if result == nil {
 				continue
 			}
+			block := result.Block
+			work := result.Work
+
+			work.state.Sync()
+			if self.fullValidation {
+				if _, err := self.chain.InsertChain(types.Blocks{block}); err != nil {
+					glog.V(logger.Error).Infoln("mining err", err)
+					continue
+				}
+				go self.mux.Post(core.NewMinedBlockEvent{block})
+			} else {
+				parent := self.chain.GetBlock(block.ParentHash())
+				if parent == nil {
+					glog.V(logger.Error).Infoln("Invalid block found during mining")
+					continue
+				}
+				if err := core.ValidateHeader(self.eth.BlockProcessor().Pow, block.Header(), parent, true); err != nil && err != core.BlockFutureErr {
+					glog.V(logger.Error).Infoln("Invalid header on mined block:", err)
+					continue
+				}
 
-			parent := self.chain.GetBlock(block.ParentHash())
-			if parent == nil {
-				glog.V(logger.Error).Infoln("Invalid block found during mining")
-				continue
-			}
-			if err := core.ValidateHeader(self.eth.BlockProcessor().Pow, block.Header(), parent, true); err != nil && err != core.BlockFutureErr {
-				glog.V(logger.Error).Infoln("Invalid header on mined block:", err)
-				continue
-			}
+				stat, err := self.chain.WriteBlock(block, false)
+				if err != nil {
+					glog.V(logger.Error).Infoln("error writing block to chain", err)
+					continue
+				}
+				// check if canon block and write transactions
+				if stat == core.CanonStatTy {
+					// This puts transactions in a extra db for rpc
+					core.PutTransactions(self.extraDb, block, block.Transactions())
+					// store the receipts
+					core.PutReceipts(self.extraDb, work.receipts)
+				}
 
-			stat, err := self.chain.WriteBlock(block, false)
-			if err != nil {
-				glog.V(logger.Error).Infoln("error writing block to chain", err)
-				continue
-			}
-			// check if canon block and write transactions
-			if stat == core.CanonStatTy {
-				// This puts transactions in a extra db for rpc
-				core.PutTransactions(self.extraDb, block, block.Transactions())
-				// store the receipts
-				core.PutReceipts(self.extraDb, self.current.receipts)
+				// broadcast before waiting for validation
+				go func(block *types.Block, logs state.Logs) {
+					self.mux.Post(core.NewMinedBlockEvent{block})
+					self.mux.Post(core.ChainEvent{block, block.Hash(), logs})
+					if stat == core.CanonStatTy {
+						self.mux.Post(core.ChainHeadEvent{block})
+						self.mux.Post(logs)
+					}
+				}(block, work.state.Logs())
 			}
 
 			// check staleness and display confirmation
@@ -287,29 +314,18 @@ func (self *worker) wait() {
 				stale = "stale "
 			} else {
 				confirm = "Wait 5 blocks for confirmation"
-				self.current.localMinedBlocks = newLocalMinedBlock(block.Number().Uint64(), self.current.localMinedBlocks)
+				work.localMinedBlocks = newLocalMinedBlock(block.Number().Uint64(), work.localMinedBlocks)
 			}
-
 			glog.V(logger.Info).Infof("🔨  Mined %sblock (#%v / %x). %s", stale, block.Number(), block.Hash().Bytes()[:4], confirm)
 
-			// broadcast before waiting for validation
-			go func(block *types.Block, logs state.Logs) {
-				self.mux.Post(core.NewMinedBlockEvent{block})
-				self.mux.Post(core.ChainEvent{block, block.Hash(), logs})
-				if stat == core.CanonStatTy {
-					self.mux.Post(core.ChainHeadEvent{block})
-					self.mux.Post(logs)
-				}
-			}(block, self.current.state.Logs())
-
 			self.commitNewWork()
 		}
 	}
 }
 
-func (self *worker) push() {
+func (self *worker) push(work *Work) {
 	if atomic.LoadInt32(&self.mining) == 1 {
-		if core.Canary(self.current.state) {
+		if core.Canary(work.state) {
 			glog.Infoln("Toxicity levels rising to deadly levels. Your canary has died. You can go back or continue down the mineshaft --more--")
 			glog.Infoln("You turn back and abort mining")
 			return
@@ -320,7 +336,7 @@ func (self *worker) push() {
 			atomic.AddInt32(&self.atWork, 1)
 
 			if agent.Work() != nil {
-				agent.Work() <- self.current.block
+				agent.Work() <- work
 			}
 		}
 	}
@@ -329,35 +345,36 @@ func (self *worker) push() {
 // makeCurrent creates a new environment for the current cycle.
 func (self *worker) makeCurrent(parent *types.Block, header *types.Header) {
 	state := state.New(parent.Root(), self.eth.StateDb())
-	current := &environment{
+	work := &Work{
 		state:     state,
 		ancestors: set.New(),
 		family:    set.New(),
 		uncles:    set.New(),
 		header:    header,
 		coinbase:  state.GetOrNewStateObject(self.coinbase),
+		createdAt: time.Now(),
 	}
 
 	// when 08 is processed ancestors contain 07 (quick block)
 	for _, ancestor := range self.chain.GetBlocksFromHash(parent.Hash(), 7) {
 		for _, uncle := range ancestor.Uncles() {
-			current.family.Add(uncle.Hash())
+			work.family.Add(uncle.Hash())
 		}
-		current.family.Add(ancestor.Hash())
-		current.ancestors.Add(ancestor.Hash())
+		work.family.Add(ancestor.Hash())
+		work.ancestors.Add(ancestor.Hash())
 	}
 	accounts, _ := self.eth.AccountManager().Accounts()
 
 	// Keep track of transactions which return errors so they can be removed
-	current.remove = set.New()
-	current.tcount = 0
-	current.ignoredTransactors = set.New()
-	current.lowGasTransactors = set.New()
-	current.ownedAccounts = accountAddressesSet(accounts)
+	work.remove = set.New()
+	work.tcount = 0
+	work.ignoredTransactors = set.New()
+	work.lowGasTransactors = set.New()
+	work.ownedAccounts = accountAddressesSet(accounts)
 	if self.current != nil {
-		current.localMinedBlocks = self.current.localMinedBlocks
+		work.localMinedBlocks = self.current.localMinedBlocks
 	}
-	self.current = current
+	self.current = work
 }
 
 func (w *worker) setGasPrice(p *big.Int) {
@@ -371,13 +388,13 @@ func (w *worker) setGasPrice(p *big.Int) {
 	w.mux.Post(core.GasPriceChanged{w.gasPrice})
 }
 
-func (self *worker) isBlockLocallyMined(deepBlockNum uint64) bool {
+func (self *worker) isBlockLocallyMined(current *Work, deepBlockNum uint64) bool {
 	//Did this instance mine a block at {deepBlockNum} ?
 	var isLocal = false
-	for idx, blockNum := range self.current.localMinedBlocks.ints {
+	for idx, blockNum := range current.localMinedBlocks.ints {
 		if deepBlockNum == blockNum {
 			isLocal = true
-			self.current.localMinedBlocks.ints[idx] = 0 //prevent showing duplicate logs
+			current.localMinedBlocks.ints[idx] = 0 //prevent showing duplicate logs
 			break
 		}
 	}
@@ -391,12 +408,12 @@ func (self *worker) isBlockLocallyMined(deepBlockNum uint64) bool {
 	return block != nil && block.Coinbase() == self.coinbase
 }
 
-func (self *worker) logLocalMinedBlocks(previous *environment) {
-	if previous != nil && self.current.localMinedBlocks != nil {
-		nextBlockNum := self.current.block.NumberU64()
-		for checkBlockNum := previous.block.NumberU64(); checkBlockNum < nextBlockNum; checkBlockNum++ {
+func (self *worker) logLocalMinedBlocks(current, previous *Work) {
+	if previous != nil && current.localMinedBlocks != nil {
+		nextBlockNum := current.Block.NumberU64()
+		for checkBlockNum := previous.Block.NumberU64(); checkBlockNum < nextBlockNum; checkBlockNum++ {
 			inspectBlockNum := checkBlockNum - miningLogAtDepth
-			if self.isBlockLocallyMined(inspectBlockNum) {
+			if self.isBlockLocallyMined(current, inspectBlockNum) {
 				glog.V(logger.Info).Infof("🔨 🔗  Mined %d blocks back: block #%v", miningLogAtDepth, inspectBlockNum)
 			}
 		}
@@ -428,7 +445,7 @@ func (self *worker) commitNewWork() {
 	header := &types.Header{
 		ParentHash: parent.Hash(),
 		Number:     num.Add(num, common.Big1),
-		Difficulty: core.CalcDifficulty(uint64(tstamp), parent.Time(), parent.Difficulty()),
+		Difficulty: core.CalcDifficulty(uint64(tstamp), parent.Time(), parent.Number(), parent.Difficulty()),
 		GasLimit:   core.CalcGasLimit(parent),
 		GasUsed:    new(big.Int),
 		Coinbase:   self.coinbase,
@@ -438,14 +455,47 @@ func (self *worker) commitNewWork() {
 
 	previous := self.current
 	self.makeCurrent(parent, header)
-	current := self.current
+	work := self.current
 
-	// commit transactions for this run.
+	/* //approach 1
 	transactions := self.eth.TxPool().GetTransactions()
 	sort.Sort(types.TxByNonce{transactions})
-	current.coinbase.SetGasLimit(header.GasLimit)
-	current.commitTransactions(transactions, self.gasPrice, self.proc)
-	self.eth.TxPool().RemoveTransactions(current.lowGasTxs)
+	*/
+
+	//approach 2
+	transactions := self.eth.TxPool().GetTransactions()
+	sort.Sort(types.TxByPriceAndNonce{transactions})
+
+	/* // approach 3
+	// commit transactions for this run.
+	txPerOwner := make(map[common.Address]types.Transactions)
+	// Sort transactions by owner
+	for _, tx := range self.eth.TxPool().GetTransactions() {
+		from, _ := tx.From() // we can ignore the sender error
+		txPerOwner[from] = append(txPerOwner[from], tx)
+	}
+	var (
+		singleTxOwner types.Transactions
+		multiTxOwner  types.Transactions
+	)
+	// Categorise transactions by
+	// 1. 1 owner tx per block
+	// 2. multi txs owner per block
+	for _, txs := range txPerOwner {
+		if len(txs) == 1 {
+			singleTxOwner = append(singleTxOwner, txs[0])
+		} else {
+			multiTxOwner = append(multiTxOwner, txs...)
+		}
+	}
+	sort.Sort(types.TxByPrice{singleTxOwner})
+	sort.Sort(types.TxByNonce{multiTxOwner})
+	transactions := append(singleTxOwner, multiTxOwner...)
+	*/
+
+	work.coinbase.SetGasLimit(header.GasLimit)
+	work.commitTransactions(transactions, self.gasPrice, self.proc)
+	self.eth.TxPool().RemoveTransactions(work.lowGasTxs)
 
 	// compute uncles for the new block.
 	var (
@@ -456,7 +506,7 @@ func (self *worker) commitNewWork() {
 		if len(uncles) == 2 {
 			break
 		}
-		if err := self.commitUncle(uncle.Header()); err != nil {
+		if err := self.commitUncle(work, uncle.Header()); err != nil {
 			if glog.V(logger.Ridiculousness) {
 				glog.V(logger.Detail).Infof("Bad uncle found and will be removed (%x)\n", hash[:4])
 				glog.V(logger.Detail).Infoln(uncle)
@@ -473,41 +523,40 @@ func (self *worker) commitNewWork() {
 
 	if atomic.LoadInt32(&self.mining) == 1 {
 		// commit state root after all state transitions.
-		core.AccumulateRewards(self.current.state, header, uncles)
-		current.state.SyncObjects()
-		self.current.state.Sync()
-		header.Root = current.state.Root()
+		core.AccumulateRewards(work.state, header, uncles)
+		work.state.SyncObjects()
+		header.Root = work.state.Root()
 	}
 
 	// create the new block whose nonce will be mined.
-	current.block = types.NewBlock(header, current.txs, uncles, current.receipts)
-	self.current.block.Td = new(big.Int).Set(core.CalcTD(self.current.block, self.chain.GetBlock(self.current.block.ParentHash())))
+	work.Block = types.NewBlock(header, work.txs, uncles, work.receipts)
+	work.Block.Td = new(big.Int).Set(core.CalcTD(work.Block, self.chain.GetBlock(work.Block.ParentHash())))
 
 	// We only care about logging if we're actually mining.
 	if atomic.LoadInt32(&self.mining) == 1 {
-		glog.V(logger.Info).Infof("commit new work on block %v with %d txs & %d uncles. Took %v\n", current.block.Number(), current.tcount, len(uncles), time.Since(tstart))
-		self.logLocalMinedBlocks(previous)
+		glog.V(logger.Info).Infof("commit new work on block %v with %d txs & %d uncles. Took %v\n", work.Block.Number(), work.tcount, len(uncles), time.Since(tstart))
+		self.logLocalMinedBlocks(work, previous)
 	}
 
-	self.push()
+	self.push(work)
 }
 
-func (self *worker) commitUncle(uncle *types.Header) error {
+func (self *worker) commitUncle(work *Work, uncle *types.Header) error {
 	hash := uncle.Hash()
-	if self.current.uncles.Has(hash) {
+	if work.uncles.Has(hash) {
 		return core.UncleError("Uncle not unique")
 	}
-	if !self.current.ancestors.Has(uncle.ParentHash) {
+	if !work.ancestors.Has(uncle.ParentHash) {
 		return core.UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4]))
 	}
-	if self.current.family.Has(hash) {
+	if work.family.Has(hash) {
 		return core.UncleError(fmt.Sprintf("Uncle already in family (%x)", hash))
 	}
-	self.current.uncles.Add(uncle.Hash())
+	work.uncles.Add(uncle.Hash())
 	return nil
 }
 
-func (env *environment) commitTransactions(transactions types.Transactions, gasPrice *big.Int, proc *core.BlockProcessor) {
+func (env *Work) commitTransactions(transactions types.Transactions, gasPrice *big.Int, proc *core.BlockProcessor) {
 	for _, tx := range transactions {
 		// We can skip err. It has already been validated in the tx pool
 		from, _ := tx.From()
@@ -565,7 +614,7 @@ func (env *environment) commitTransactions(transactions types.Transactions, gasP
 	}
 }
 
-func (env *environment) commitTransaction(tx *types.Transaction, proc *core.BlockProcessor) error {
+func (env *Work) commitTransaction(tx *types.Transaction, proc *core.BlockProcessor) error {
 	snap := env.state.Copy()
 	receipt, _, err := proc.ApplyTransaction(env.coinbase, env.state, env.header, tx, env.header.GasUsed, true)
 	if err != nil {