package ethminer import ( "bytes" "sort" "github.com/ethereum/go-ethereum/ethchain" "github.com/ethereum/go-ethereum/ethlog" "github.com/ethereum/go-ethereum/ethwire" "github.com/ethereum/go-ethereum/event" ) var logger = ethlog.NewLogger("MINER") type Miner struct { pow ethchain.PoW ethereum ethchain.EthManager coinbase []byte txs ethchain.Transactions uncles []*ethchain.Block block *ethchain.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() ethchain.PoW { return self.pow } func NewDefaultMiner(coinbase []byte, ethereum ethchain.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(ethchain.NewBlockEvent{}, ethchain.TxEvent{}) // Prepare inital block //miner.ethereum.StateManager().Prepare(miner.block.State(), miner.block.State()) go miner.listener() logger.Infoln("Started") mux.Post(Event{Started, miner}) } func (miner *Miner) Stop() { logger.Infoln("Stopping...") miner.events.Unsubscribe() miner.ethereum.EventMux().Post(Event{Stopped, miner}) } func (miner *Miner) listener() { miner.startMining() for { select { case event, isopen := <-miner.events.Chan(): if !isopen { return } switch event := event.(type) { case ethchain.NewBlockEvent: miner.stopMining() block := event.Block //logger.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 //logger.Infoln("New top block found resetting state") // Filter out which Transactions we have that were not in this block var newtxs []*ethchain.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 // Setup a fresh state to mine on //miner.block = miner.ethereum.ChainManager().NewBlock(miner.coinbase, miner.txs) } else { if bytes.Compare(block.PrevHash, miner.ethereum.ChainManager().CurrentBlock.PrevHash) == 0 { logger.Infoln("Adding uncle block") miner.uncles = append(miner.uncles, block) } } case ethchain.TxEvent: if event.Type == ethchain.TxPre { miner.stopMining() found := false for _, ctx := range miner.txs { if found = bytes.Compare(ctx.Hash(), event.Tx.Hash()) == 0; found { break } } 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() { 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(ethchain.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 { logger.Debugln(err) } self.ethereum.TxPool().RemoveSet(erroneous) self.txs = append(txs, unhandledTxs...) self.block.SetTxHash(receipts) // Set the transactions to the block so the new SHA3 can be calculated self.block.SetReceipts(receipts, txs) // Accumulate the rewards included for this block stateManager.AccumelateRewards(self.block.State(), self.block, parent) self.block.State().Update() logger.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, false) if err != nil { logger.Infoln(err) } else { self.ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{self.block.Value().Val}) logger.Infof("🔨 Mined block %x\n", self.block.Hash()) logger.Infoln(self.block) // Gather the new batch of transactions currently in the tx pool self.txs = self.ethereum.TxPool().CurrentTransactions() } } self.powDone <- struct{}{} }