From 5af4ff985dc43b648bdc96394a3bd96d9658ae0a Mon Sep 17 00:00:00 2001 From: obscuren Date: Fri, 31 Oct 2014 14:56:42 +0100 Subject: [PATCH] ethminer => miner --- cmd/mist/gui.go | 10 +-- cmd/utils/cmd.go | 18 ++-- miner/miner.go | 217 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 231 insertions(+), 14 deletions(-) create mode 100644 miner/miner.go diff --git a/cmd/mist/gui.go b/cmd/mist/gui.go index d309e0a9b..d6f6832e2 100644 --- a/cmd/mist/gui.go +++ b/cmd/mist/gui.go @@ -33,9 +33,9 @@ import ( "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/chain" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethminer" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/miner" "github.com/ethereum/go-ethereum/wire" "github.com/ethereum/go-ethereum/xeth" "gopkg.in/qml.v1" @@ -92,7 +92,7 @@ type Gui struct { plugins map[string]plugin - miner *ethminer.Miner + miner *miner.Miner stdLog logger.LogSystem } @@ -410,7 +410,7 @@ func (gui *Gui) update() { chain.NewBlockEvent{}, chain.TxPreEvent{}, chain.TxPostEvent{}, - ethminer.Event{}, + miner.Event{}, ) // nameReg := gui.pipe.World().Config().Get("NameReg") @@ -469,8 +469,8 @@ func (gui *Gui) update() { case eth.PeerListEvent: gui.setPeerInfo() - case ethminer.Event: - if ev.Type == ethminer.Started { + case miner.Event: + if ev.Type == miner.Started { gui.miner = ev.Miner } else { gui.miner = nil diff --git a/cmd/utils/cmd.go b/cmd/utils/cmd.go index 5313b8fad..ef2ce8b47 100644 --- a/cmd/utils/cmd.go +++ b/cmd/utils/cmd.go @@ -16,9 +16,9 @@ import ( "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethdb" - "github.com/ethereum/go-ethereum/ethminer" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/miner" "github.com/ethereum/go-ethereum/rpc" "github.com/ethereum/go-ethereum/wire" "github.com/ethereum/go-ethereum/xeth" @@ -252,10 +252,10 @@ func StartRpc(ethereum *eth.Ethereum, RpcPort int) { } } -var miner *ethminer.Miner +var gminer *miner.Miner -func GetMiner() *ethminer.Miner { - return miner +func GetMiner() *miner.Miner { + return gminer } func StartMining(ethereum *eth.Ethereum) bool { @@ -265,15 +265,15 @@ func StartMining(ethereum *eth.Ethereum) bool { go func() { clilogger.Infoln("Start mining") - if miner == nil { - miner = ethminer.NewDefaultMiner(addr, ethereum) + if gminer == nil { + gminer = miner.NewDefaultMiner(addr, ethereum) } // Give it some time to connect with peers time.Sleep(3 * time.Second) for !ethereum.IsUpToDate() { time.Sleep(5 * time.Second) } - miner.Start() + gminer.Start() }() RegisterInterrupt(func(os.Signal) { StopMining(ethereum) @@ -297,8 +297,8 @@ func FormatTransactionData(data string) []byte { } func StopMining(ethereum *eth.Ethereum) bool { - if ethereum.Mining && miner != nil { - miner.Stop() + if ethereum.Mining && gminer != nil { + gminer.Stop() clilogger.Infoln("Stopped mining") ethereum.Mining = false diff --git a/miner/miner.go b/miner/miner.go new file mode 100644 index 000000000..b11bd9532 --- /dev/null +++ b/miner/miner.go @@ -0,0 +1,217 @@ +package miner + +import ( + "bytes" + "sort" + + "github.com/ethereum/go-ethereum/chain" + "github.com/ethereum/go-ethereum/event" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/wire" +) + +var minerlogger = logger.NewLogger("MINER") + +type Miner struct { + pow chain.PoW + ethereum chain.EthManager + coinbase []byte + txs chain.Transactions + uncles []*chain.Block + block *chain.Block + + events event.Subscription + powQuitChan chan struct{} + powDone chan struct{} + + turbo bool +} + +const ( + Started = iota + Stopped +) + +type Event struct { + Type int // Started || Stopped + Miner *Miner +} + +func (self *Miner) GetPow() chain.PoW { + return self.pow +} + +func NewDefaultMiner(coinbase []byte, ethereum chain.EthManager) *Miner { + miner := Miner{ + pow: &chain.EasyPow{}, + ethereum: ethereum, + coinbase: coinbase, + } + + return &miner +} + +func (self *Miner) ToggleTurbo() { + self.turbo = !self.turbo + + self.pow.Turbo(self.turbo) +} + +func (miner *Miner) Start() { + + // Insert initial TXs in our little miner 'pool' + miner.txs = miner.ethereum.TxPool().Flush() + miner.block = miner.ethereum.ChainManager().NewBlock(miner.coinbase) + + mux := miner.ethereum.EventMux() + miner.events = mux.Subscribe(chain.NewBlockEvent{}, chain.TxPreEvent{}) + + // Prepare inital block + //miner.ethereum.StateManager().Prepare(miner.block.State(), miner.block.State()) + go miner.listener() + + minerlogger.Infoln("Started") + mux.Post(Event{Started, miner}) +} + +func (miner *Miner) Stop() { + minerlogger.Infoln("Stopping...") + miner.events.Unsubscribe() + miner.ethereum.EventMux().Post(Event{Stopped, miner}) +} + +func (miner *Miner) listener() { + miner.startMining() + + for { + select { + case event := <-miner.events.Chan(): + switch event := event.(type) { + case chain.NewBlockEvent: + miner.stopMining() + + block := event.Block + //minerlogger.Infoln("Got new block via Reactor") + if bytes.Compare(miner.ethereum.ChainManager().CurrentBlock.Hash(), block.Hash()) == 0 { + // TODO: Perhaps continue mining to get some uncle rewards + //minerlogger.Infoln("New top block found resetting state") + + // Filter out which Transactions we have that were not in this block + var newtxs []*chain.Transaction + for _, tx := range miner.txs { + found := false + for _, othertx := range block.Transactions() { + if bytes.Compare(tx.Hash(), othertx.Hash()) == 0 { + found = true + } + } + if found == false { + newtxs = append(newtxs, tx) + } + } + miner.txs = newtxs + } else { + if bytes.Compare(block.PrevHash, miner.ethereum.ChainManager().CurrentBlock.PrevHash) == 0 { + minerlogger.Infoln("Adding uncle block") + miner.uncles = append(miner.uncles, block) + } + } + miner.startMining() + + case chain.TxPreEvent: + miner.stopMining() + + found := false + for _, ctx := range miner.txs { + if found = bytes.Compare(ctx.Hash(), event.Tx.Hash()) == 0; found { + break + } + + miner.startMining() + } + if found == false { + // Undo all previous commits + miner.block.Undo() + // Apply new transactions + miner.txs = append(miner.txs, event.Tx) + } + } + + case <-miner.powDone: + miner.startMining() + } + } +} + +func (miner *Miner) startMining() { + if miner.powDone == nil { + miner.powDone = make(chan struct{}) + } + miner.powQuitChan = make(chan struct{}) + go miner.mineNewBlock() +} + +func (miner *Miner) stopMining() { + println("stop mining") + _, isopen := <-miner.powQuitChan + if isopen { + close(miner.powQuitChan) + } + //<-miner.powDone +} + +func (self *Miner) mineNewBlock() { + stateManager := self.ethereum.StateManager() + + self.block = self.ethereum.ChainManager().NewBlock(self.coinbase) + + // Apply uncles + if len(self.uncles) > 0 { + self.block.SetUncles(self.uncles) + } + + // Sort the transactions by nonce in case of odd network propagation + sort.Sort(chain.TxByNonce{self.txs}) + + // Accumulate all valid transactions and apply them to the new state + // Error may be ignored. It's not important during mining + parent := self.ethereum.ChainManager().GetBlock(self.block.PrevHash) + coinbase := self.block.State().GetOrNewStateObject(self.block.Coinbase) + coinbase.SetGasPool(self.block.CalcGasLimit(parent)) + receipts, txs, unhandledTxs, erroneous, err := stateManager.ProcessTransactions(coinbase, self.block.State(), self.block, self.block, self.txs) + if err != nil { + minerlogger.Debugln(err) + } + self.ethereum.TxPool().RemoveSet(erroneous) + self.txs = append(txs, unhandledTxs...) + + self.block.SetTransactions(txs) + self.block.SetReceipts(receipts) + + // Accumulate the rewards included for this block + stateManager.AccumelateRewards(self.block.State(), self.block, parent) + + self.block.State().Update() + + minerlogger.Infof("Mining on block. Includes %v transactions", len(self.txs)) + + // Find a valid nonce + nonce := self.pow.Search(self.block, self.powQuitChan) + if nonce != nil { + self.block.Nonce = nonce + err := self.ethereum.StateManager().Process(self.block) + if err != nil { + minerlogger.Infoln(err) + } else { + self.ethereum.Broadcast(wire.MsgBlockTy, []interface{}{self.block.Value().Val}) + minerlogger.Infof("🔨 Mined block %x\n", self.block.Hash()) + minerlogger.Infoln(self.block) + // Gather the new batch of transactions currently in the tx pool + self.txs = self.ethereum.TxPool().CurrentTransactions() + self.ethereum.EventMux().Post(chain.NewBlockEvent{self.block}) + } + + // Continue mining on the next block + self.startMining() + } +}