1 files changed, 246 insertions, 0 deletions
diff --git a/miner/worker.go b/miner/worker.go
new file mode 100644
index 000000000..4f0909302
--- /dev/null
+++ b/miner/worker.go
@@ -0,0 +1,246 @@
+package miner
+
+import (
+	"fmt"
+	"math/big"
+	"sort"
+	"sync"
+
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/event"
+	"github.com/ethereum/go-ethereum/pow"
+	"github.com/ethereum/go-ethereum/state"
+	"gopkg.in/fatih/set.v0"
+)
+
+type environment struct {
+	totalUsedGas *big.Int
+	state        *state.StateDB
+	coinbase     *state.StateObject
+	block        *types.Block
+	ancestors    *set.Set
+	uncles       *set.Set
+}
+
+func env(block *types.Block, eth core.Backend) *environment {
+	state := state.New(block.Root(), eth.Db())
+	env := &environment{
+		totalUsedGas: new(big.Int),
+		state:        state,
+		block:        block,
+		ancestors:    set.New(),
+		uncles:       set.New(),
+		coinbase:     state.GetOrNewStateObject(block.Coinbase()),
+	}
+	for _, ancestor := range eth.ChainManager().GetAncestors(block, 7) {
+		env.ancestors.Add(string(ancestor.Hash()))
+	}
+
+	return env
+}
+
+type Work struct {
+	Number uint64
+	Nonce  []byte
+}
+
+type Agent interface {
+	Work() chan<- *types.Block
+	SetWorkCh(chan<- Work)
+	Stop()
+	Start()
+	Pow() pow.PoW
+}
+
+type worker struct {
+	mu     sync.Mutex
+	agents []Agent
+	recv   chan Work
+	mux    *event.TypeMux
+	quit   chan struct{}
+	pow    pow.PoW
+
+	eth      core.Backend
+	chain    *core.ChainManager
+	proc     *core.BlockProcessor
+	coinbase []byte
+
+	current *environment
+
+	mining bool
+}
+
+func newWorker(coinbase []byte, eth core.Backend) *worker {
+	return &worker{
+		eth:      eth,
+		mux:      eth.EventMux(),
+		recv:     make(chan Work),
+		chain:    eth.ChainManager(),
+		proc:     eth.BlockProcessor(),
+		coinbase: coinbase,
+	}
+}
+
+func (self *worker) start() {
+	self.mining = true
+
+	self.quit = make(chan struct{})
+
+	// spin up agents
+	for _, agent := range self.agents {
+		agent.Start()
+	}
+
+	go self.update()
+	go self.wait()
+}
+
+func (self *worker) stop() {
+	self.mining = false
+
+	close(self.quit)
+}
+
+func (self *worker) register(agent Agent) {
+	self.agents = append(self.agents, agent)
+	agent.SetWorkCh(self.recv)
+}
+
+func (self *worker) update() {
+	events := self.mux.Subscribe(core.ChainEvent{}, core.NewMinedBlockEvent{})
+
+out:
+	for {
+		select {
+		case event := <-events.Chan():
+			switch ev := event.(type) {
+			case core.ChainEvent:
+				if self.current.block != ev.Block {
+					self.commitNewWork()
+				}
+			case core.NewMinedBlockEvent:
+				self.commitNewWork()
+			}
+		case <-self.quit:
+			// stop all agents
+			for _, agent := range self.agents {
+				agent.Stop()
+			}
+			break out
+		}
+	}
+
+	events.Unsubscribe()
+}
+
+func (self *worker) wait() {
+	for {
+		for work := range self.recv {
+			block := self.current.block
+			if block.Number().Uint64() == work.Number && block.Nonce() == nil {
+				self.current.block.Header().Nonce = work.Nonce
+
+				if err := self.chain.InsertChain(types.Blocks{self.current.block}); err == nil {
+					self.mux.Post(core.NewMinedBlockEvent{self.current.block})
+				} else {
+					self.commitNewWork()
+				}
+			}
+			break
+		}
+	}
+}
+
+func (self *worker) push() {
+	if self.mining {
+		self.current.block.Header().GasUsed = self.current.totalUsedGas
+		self.current.block.SetRoot(self.current.state.Root())
+
+		// push new work to agents
+		for _, agent := range self.agents {
+			agent.Work() <- self.current.block
+		}
+	}
+}
+
+func (self *worker) commitNewWork() {
+	self.mu.Lock()
+	defer self.mu.Unlock()
+
+	self.current = env(self.chain.NewBlock(self.coinbase), self.eth)
+	parent := self.chain.GetBlock(self.current.block.ParentHash())
+	self.current.coinbase.SetGasPool(core.CalcGasLimit(parent, self.current.block))
+
+	transactions := self.eth.TxPool().GetTransactions()
+	sort.Sort(types.TxByNonce{transactions})
+
+	minerlogger.Infof("committing new work with %d txs\n", len(transactions))
+	// Keep track of transactions which return errors so they can be removed
+	var remove types.Transactions
+gasLimit:
+	for _, tx := range transactions {
+		err := self.commitTransaction(tx)
+		switch {
+		case core.IsNonceErr(err):
+			// Remove invalid transactions
+			remove = append(remove, tx)
+		case state.IsGasLimitErr(err):
+			// Break on gas limit
+			break gasLimit
+		}
+
+		if err != nil {
+			minerlogger.Infoln(err)
+		}
+	}
+	self.eth.TxPool().RemoveSet(remove)
+
+	self.current.coinbase.AddBalance(core.BlockReward)
+
+	self.current.state.Update(ethutil.Big0)
+	self.push()
+}
+
+var (
+	inclusionReward = new(big.Int).Div(core.BlockReward, big.NewInt(32))
+	_uncleReward    = new(big.Int).Mul(core.BlockReward, big.NewInt(15))
+	uncleReward     = new(big.Int).Div(_uncleReward, big.NewInt(16))
+)
+
+func (self *worker) commitUncle(uncle *types.Header) error {
+	if self.current.uncles.Has(string(uncle.Hash())) {
+		// Error not unique
+		return core.UncleError("Uncle not unique")
+	}
+	self.current.uncles.Add(string(uncle.Hash()))
+
+	if !self.current.ancestors.Has(string(uncle.ParentHash)) {
+		return core.UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4]))
+	}
+
+	if !self.pow.Verify(types.NewBlockWithHeader(uncle)) {
+		return core.ValidationError("Uncle's nonce is invalid (= %v)", ethutil.Bytes2Hex(uncle.Nonce))
+	}
+
+	uncleAccount := self.current.state.GetAccount(uncle.Coinbase)
+	uncleAccount.AddBalance(uncleReward)
+
+	self.current.coinbase.AddBalance(uncleReward)
+
+	return nil
+}
+
+func (self *worker) commitTransaction(tx *types.Transaction) error {
+	//fmt.Printf("proc %x %v\n", tx.Hash()[:3], tx.Nonce())
+	receipt, _, err := self.proc.ApplyTransaction(self.current.coinbase, self.current.state, self.current.block, tx, self.current.totalUsedGas, true)
+	if err != nil && (core.IsNonceErr(err) || state.IsGasLimitErr(err)) {
+		return err
+	}
+
+	self.current.block.AddTransaction(tx)
+	self.current.block.AddReceipt(receipt)
+
+	return nil
+}