2015-07-06 17:54:22 -07:00
// Copyright 2015 The go-ethereum Authors
// This file is part of go-ethereum.
//
// go-ethereum 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,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// 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/>.
2015-02-04 05:52:59 -08:00
package miner
import (
"fmt"
"math/big"
"sort"
2015-02-15 07:16:27 -08:00
"sync"
2015-03-26 09:45:03 -07:00
"sync/atomic"
2015-06-15 02:33:08 -07:00
"time"
2015-02-04 05:52:59 -08:00
2015-05-10 14:12:18 -07:00
"github.com/ethereum/go-ethereum/accounts"
2015-03-18 05:00:01 -07:00
"github.com/ethereum/go-ethereum/common"
2015-02-04 05:52:59 -08:00
"github.com/ethereum/go-ethereum/core"
2015-03-23 10:27:05 -07:00
"github.com/ethereum/go-ethereum/core/state"
2015-02-04 05:52:59 -08:00
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/event"
2015-03-01 07:09:59 -08:00
"github.com/ethereum/go-ethereum/logger"
2015-04-04 14:04:19 -07:00
"github.com/ethereum/go-ethereum/logger/glog"
2015-02-04 05:52:59 -08:00
"github.com/ethereum/go-ethereum/pow"
"gopkg.in/fatih/set.v0"
)
2015-03-01 07:09:59 -08:00
var jsonlogger = logger . NewJsonLogger ( )
2015-05-11 12:47:34 -07:00
// Work holds the current work
type Work struct {
Number uint64
Nonce uint64
MixDigest [ ] byte
SeedHash [ ] byte
}
// Agent can register themself with the worker
type Agent interface {
Work ( ) chan <- * types . Block
SetReturnCh ( chan <- * types . Block )
Stop ( )
Start ( )
GetHashRate ( ) int64
}
2015-05-23 12:00:18 -07:00
const miningLogAtDepth = 5
2015-05-21 08:50:01 -07:00
2015-05-23 12:04:00 -07:00
type uint64RingBuffer struct {
2015-05-21 08:50:01 -07:00
ints [ ] uint64 //array of all integers in buffer
next int //where is the next insertion? assert 0 <= next < len(ints)
}
2015-05-11 12:47:34 -07:00
// environment is the workers current environment and holds
// all of the current state information
2015-02-04 05:52:59 -08:00
type environment struct {
2015-05-11 12:47:34 -07:00
state * state . StateDB // apply state changes here
coinbase * state . StateObject // the miner's account
2015-05-13 17:46:23 -07:00
ancestors * set . Set // ancestor set (used for checking uncle parent validity)
family * set . Set // family set (used for checking uncle invalidity)
2015-05-11 12:47:34 -07:00
uncles * set . Set // uncle set
remove * set . Set // tx which will be removed
tcount int // tx count in cycle
2015-05-10 16:28:15 -07:00
ignoredTransactors * set . Set
lowGasTransactors * set . Set
ownedAccounts * set . Set
lowGasTxs types . Transactions
2015-05-23 12:04:00 -07:00
localMinedBlocks * uint64RingBuffer // the most recent block numbers that were mined locally (used to check block inclusion)
2015-02-04 05:52:59 -08:00
2015-06-16 03:41:50 -07:00
block * types . Block // the new block
2015-02-04 05:52:59 -08:00
2015-06-16 03:41:50 -07:00
header * types . Header
txs [ ] * types . Transaction
receipts [ ] * types . Receipt
2015-02-04 05:52:59 -08:00
}
2015-05-11 12:47:34 -07:00
// worker is the main object which takes care of applying messages to the new state
2015-02-04 05:52:59 -08:00
type worker struct {
2015-03-26 09:45:03 -07:00
mu sync . Mutex
2015-02-09 07:20:34 -08:00
agents [ ] Agent
2015-03-24 02:34:06 -07:00
recv chan * types . Block
2015-02-04 05:52:59 -08:00
mux * event . TypeMux
quit chan struct { }
pow pow . PoW
2015-07-03 02:24:42 -07:00
eth core . Backend
chain * core . ChainManager
proc * core . BlockProcessor
extraDb common . Database
2015-04-05 09:57:03 -07:00
2015-03-18 05:00:01 -07:00
coinbase common . Address
2015-05-09 03:04:00 -07:00
gasPrice * big . Int
2015-04-05 09:57:03 -07:00
extra [ ] byte
2015-02-04 05:52:59 -08:00
2015-04-07 03:32:55 -07:00
currentMu sync . Mutex
current * environment
2015-02-13 08:23:09 -08:00
2015-03-23 04:12:49 -07:00
uncleMu sync . Mutex
possibleUncles map [ common . Hash ] * types . Block
2015-04-07 03:32:55 -07:00
txQueueMu sync . Mutex
txQueue map [ common . Hash ] * types . Transaction
2015-04-22 01:58:43 -07:00
// atomic status counters
mining int32
atWork int32
2015-02-04 05:52:59 -08:00
}
2015-03-18 05:00:01 -07:00
func newWorker ( coinbase common . Address , eth core . Backend ) * worker {
2015-04-07 03:32:55 -07:00
worker := & worker {
2015-03-23 04:12:49 -07:00
eth : eth ,
mux : eth . EventMux ( ) ,
2015-07-03 02:24:42 -07:00
extraDb : eth . ExtraDb ( ) ,
2015-03-24 02:34:06 -07:00
recv : make ( chan * types . Block ) ,
2015-05-09 03:04:00 -07:00
gasPrice : new ( big . Int ) ,
2015-03-23 04:12:49 -07:00
chain : eth . ChainManager ( ) ,
proc : eth . BlockProcessor ( ) ,
possibleUncles : make ( map [ common . Hash ] * types . Block ) ,
coinbase : coinbase ,
2015-04-07 03:32:55 -07:00
txQueue : make ( map [ common . Hash ] * types . Transaction ) ,
2015-04-07 15:30:23 -07:00
quit : make ( chan struct { } ) ,
2015-02-09 07:20:34 -08:00
}
2015-04-07 03:32:55 -07:00
go worker . update ( )
go worker . wait ( )
worker . commitNewWork ( )
return worker
2015-02-09 07:20:34 -08:00
}
2015-07-07 01:58:47 -07:00
func ( self * worker ) setEtherbase ( addr common . Address ) {
self . mu . Lock ( )
defer self . mu . Unlock ( )
self . coinbase = addr
}
2015-04-07 03:32:55 -07:00
func ( self * worker ) pendingState ( ) * state . StateDB {
self . currentMu . Lock ( )
defer self . currentMu . Unlock ( )
return self . current . state
}
2015-02-13 08:23:09 -08:00
2015-04-07 03:32:55 -07:00
func ( self * worker ) pendingBlock ( ) * types . Block {
self . currentMu . Lock ( )
defer self . currentMu . Unlock ( )
2015-06-16 03:41:50 -07:00
if atomic . LoadInt32 ( & self . mining ) == 0 {
return types . NewBlock (
self . current . header ,
self . current . txs ,
nil ,
self . current . receipts ,
)
}
2015-04-07 03:32:55 -07:00
return self . current . block
}
func ( self * worker ) start ( ) {
2015-05-09 03:32:36 -07:00
self . mu . Lock ( )
defer self . mu . Unlock ( )
2015-05-10 16:28:15 -07:00
atomic . StoreInt32 ( & self . mining , 1 )
2015-02-14 07:52:14 -08:00
// spin up agents
for _ , agent := range self . agents {
agent . Start ( )
}
2015-02-09 07:20:34 -08:00
}
func ( self * worker ) stop ( ) {
2015-05-09 03:32:36 -07:00
self . mu . Lock ( )
defer self . mu . Unlock ( )
2015-04-22 01:58:43 -07:00
if atomic . LoadInt32 ( & self . mining ) == 1 {
2015-05-11 06:43:14 -07:00
var keep [ ] Agent
2015-04-07 15:30:23 -07:00
// stop all agents
for _ , agent := range self . agents {
agent . Stop ( )
2015-05-11 06:43:14 -07:00
// keep all that's not a cpu agent
if _ , ok := agent . ( * CpuAgent ) ; ! ok {
keep = append ( keep , agent )
}
2015-04-07 15:30:23 -07:00
}
2015-05-11 06:43:14 -07:00
self . agents = keep
2015-04-07 15:30:23 -07:00
}
2015-02-13 08:23:09 -08:00
2015-04-22 01:58:43 -07:00
atomic . StoreInt32 ( & self . mining , 0 )
atomic . StoreInt32 ( & self . atWork , 0 )
2015-02-09 07:20:34 -08:00
}
func ( self * worker ) register ( agent Agent ) {
2015-05-09 03:32:36 -07:00
self . mu . Lock ( )
defer self . mu . Unlock ( )
2015-02-04 05:52:59 -08:00
self . agents = append ( self . agents , agent )
2015-03-24 02:34:06 -07:00
agent . SetReturnCh ( self . recv )
2015-02-04 05:52:59 -08:00
}
func ( self * worker ) update ( ) {
2015-04-07 03:32:55 -07:00
events := self . mux . Subscribe ( core . ChainHeadEvent { } , core . ChainSideEvent { } , core . TxPreEvent { } )
2015-02-04 05:52:59 -08:00
out :
for {
select {
case event := <- events . Chan ( ) :
2015-02-19 13:33:22 -08:00
switch ev := event . ( type ) {
2015-03-06 06:50:44 -08:00
case core . ChainHeadEvent :
2015-02-14 07:52:14 -08:00
self . commitNewWork ( )
2015-03-23 08:14:33 -07:00
case core . ChainSideEvent :
2015-03-23 04:12:49 -07:00
self . uncleMu . Lock ( )
self . possibleUncles [ ev . Block . Hash ( ) ] = ev . Block
self . uncleMu . Unlock ( )
2015-04-07 03:32:55 -07:00
case core . TxPreEvent :
2015-05-10 16:28:15 -07:00
// Apply transaction to the pending state if we're not mining
2015-04-22 01:58:43 -07:00
if atomic . LoadInt32 ( & self . mining ) == 0 {
2015-05-10 16:28:15 -07:00
self . mu . Lock ( )
2015-06-16 03:41:50 -07:00
self . current . commitTransactions ( types . Transactions { ev . Tx } , self . gasPrice , self . proc )
2015-05-10 16:28:15 -07:00
self . mu . Unlock ( )
2015-04-07 03:32:55 -07:00
}
2015-02-04 05:52:59 -08:00
}
case <- self . quit :
break out
}
}
2015-02-13 08:23:09 -08:00
events . Unsubscribe ( )
2015-02-04 05:52:59 -08:00
}
2015-05-23 12:04:00 -07:00
func newLocalMinedBlock ( blockNumber uint64 , prevMinedBlocks * uint64RingBuffer ) ( minedBlocks * uint64RingBuffer ) {
2015-05-21 08:50:01 -07:00
if prevMinedBlocks == nil {
2015-05-27 04:16:36 -07:00
minedBlocks = & uint64RingBuffer { next : 0 , ints : make ( [ ] uint64 , miningLogAtDepth + 1 ) }
2015-05-21 08:50:01 -07:00
} else {
minedBlocks = prevMinedBlocks
}
minedBlocks . ints [ minedBlocks . next ] = blockNumber
minedBlocks . next = ( minedBlocks . next + 1 ) % len ( minedBlocks . ints )
return minedBlocks
}
2015-02-09 07:20:34 -08:00
func ( self * worker ) wait ( ) {
for {
2015-03-24 02:34:06 -07:00
for block := range self . recv {
2015-04-22 01:58:43 -07:00
atomic . AddInt32 ( & self . atWork , - 1 )
2015-03-26 09:45:03 -07:00
if block == nil {
continue
}
2015-07-03 02:24:42 -07:00
parent := self . chain . GetBlock ( block . ParentHash ( ) )
if parent == nil {
glog . V ( logger . Error ) . Infoln ( "Invalid block found during mining" )
continue
}
2015-07-03 08:21:23 -07:00
if err := core . ValidateHeader ( self . eth . BlockProcessor ( ) . Pow , block . Header ( ) , parent , true ) ; err != nil && err != core . BlockFutureErr {
2015-07-03 02:24:42 -07:00
glog . V ( logger . Error ) . Infoln ( "Invalid header on mined block:" , err )
continue
}
stat , err := self . chain . WriteBlock ( block , false )
2015-06-29 03:12:30 -07:00
if err != nil {
glog . V ( logger . Error ) . Infoln ( "error writing block to chain" , err )
continue
}
2015-07-03 02:24:42 -07:00
// 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
2015-07-03 17:25:04 -07:00
core . PutReceipts ( self . extraDb , self . current . receipts )
2015-07-03 02:24:42 -07:00
}
2015-04-02 03:58:17 -07:00
2015-06-29 03:12:30 -07:00
// check staleness and display confirmation
var stale , confirm string
canonBlock := self . chain . GetBlockByNumber ( block . NumberU64 ( ) )
if canonBlock != nil && canonBlock . Hash ( ) != block . Hash ( ) {
stale = "stale "
2015-03-24 02:34:06 -07:00
} else {
2015-06-29 03:12:30 -07:00
confirm = "Wait 5 blocks for confirmation"
self . current . localMinedBlocks = newLocalMinedBlock ( block . Number ( ) . Uint64 ( ) , self . current . localMinedBlocks )
2015-02-13 08:23:09 -08:00
}
2015-06-29 03:12:30 -07:00
glog . V ( logger . Info ) . Infof ( "🔨 Mined %sblock (#%v / %x). %s" , stale , block . Number ( ) , block . Hash ( ) . Bytes ( ) [ : 4 ] , confirm )
// broadcast before waiting for validation
2015-07-03 02:24:42 -07:00
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 } )
2015-07-08 06:18:52 -07:00
self . mux . Post ( logs )
2015-07-03 02:24:42 -07:00
}
} ( block , self . current . state . Logs ( ) )
2015-06-29 03:12:30 -07:00
self . commitNewWork ( )
2015-02-09 07:20:34 -08:00
}
}
}
func ( self * worker ) push ( ) {
2015-04-22 01:58:43 -07:00
if atomic . LoadInt32 ( & self . mining ) == 1 {
2015-06-29 03:42:47 -07:00
if core . Canary ( self . current . 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
}
2015-02-14 07:52:14 -08:00
// push new work to agents
2015-02-13 08:23:09 -08:00
for _ , agent := range self . agents {
2015-04-22 01:58:43 -07:00
atomic . AddInt32 ( & self . atWork , 1 )
2015-03-26 09:45:03 -07:00
2015-04-15 08:04:22 -07:00
if agent . Work ( ) != nil {
2015-06-16 03:41:50 -07:00
agent . Work ( ) <- self . current . block
2015-04-15 08:04:22 -07:00
}
2015-02-13 08:23:09 -08:00
}
2015-02-04 05:52:59 -08:00
}
}
2015-06-16 03:41:50 -07:00
// 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 {
state : state ,
ancestors : set . New ( ) ,
family : set . New ( ) ,
uncles : set . New ( ) ,
header : header ,
coinbase : state . GetOrNewStateObject ( self . coinbase ) ,
2015-04-04 04:27:17 -07:00
}
2015-03-05 00:14:58 -08:00
2015-05-18 07:31:26 -07:00
// when 08 is processed ancestors contain 07 (quick block)
2015-06-16 03:41:50 -07:00
for _ , ancestor := range self . chain . GetBlocksFromHash ( parent . Hash ( ) , 7 ) {
2015-05-13 17:46:23 -07:00
for _ , uncle := range ancestor . Uncles ( ) {
current . family . Add ( uncle . Hash ( ) )
}
2015-05-10 16:28:15 -07:00
current . family . Add ( ancestor . Hash ( ) )
2015-05-14 02:02:15 -07:00
current . ancestors . Add ( ancestor . Hash ( ) )
2015-03-23 04:12:49 -07:00
}
2015-05-10 16:28:15 -07:00
accounts , _ := self . eth . AccountManager ( ) . Accounts ( )
2015-06-16 03:41:50 -07:00
2015-05-10 16:28:15 -07:00
// 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 )
2015-05-21 08:50:01 -07:00
if self . current != nil {
current . localMinedBlocks = self . current . localMinedBlocks
}
2015-05-10 16:28:15 -07:00
self . current = current
2015-04-07 03:32:55 -07:00
}
2015-05-09 03:04:00 -07:00
func ( w * worker ) setGasPrice ( p * big . Int ) {
w . mu . Lock ( )
defer w . mu . Unlock ( )
2015-05-10 14:12:18 -07:00
// calculate the minimal gas price the miner accepts when sorting out transactions.
const pct = int64 ( 90 )
w . gasPrice = gasprice ( p , pct )
w . mux . Post ( core . GasPriceChanged { w . gasPrice } )
2015-05-09 03:04:00 -07:00
}
2015-05-21 08:50:01 -07:00
func ( self * worker ) isBlockLocallyMined ( deepBlockNum uint64 ) bool {
//Did this instance mine a block at {deepBlockNum} ?
var isLocal = false
for idx , blockNum := range self . current . localMinedBlocks . ints {
if deepBlockNum == blockNum {
isLocal = true
self . current . localMinedBlocks . ints [ idx ] = 0 //prevent showing duplicate logs
break
}
}
//Short-circuit on false, because the previous and following tests must both be true
if ! isLocal {
return false
}
//Does the block at {deepBlockNum} send earnings to my coinbase?
var block = self . chain . GetBlockByNumber ( deepBlockNum )
2015-06-16 03:41:50 -07:00
return block != nil && block . Coinbase ( ) == self . coinbase
2015-05-21 08:50:01 -07:00
}
func ( self * worker ) logLocalMinedBlocks ( previous * environment ) {
if previous != nil && self . current . localMinedBlocks != nil {
2015-06-16 03:41:50 -07:00
nextBlockNum := self . current . block . NumberU64 ( )
for checkBlockNum := previous . block . NumberU64 ( ) ; checkBlockNum < nextBlockNum ; checkBlockNum ++ {
2015-05-23 12:00:18 -07:00
inspectBlockNum := checkBlockNum - miningLogAtDepth
2015-05-21 08:50:01 -07:00
if self . isBlockLocallyMined ( inspectBlockNum ) {
2015-05-23 12:00:18 -07:00
glog . V ( logger . Info ) . Infof ( "🔨 🔗 Mined %d blocks back: block #%v" , miningLogAtDepth , inspectBlockNum )
2015-05-21 08:50:01 -07:00
}
}
}
}
2015-04-07 03:32:55 -07:00
func ( self * worker ) commitNewWork ( ) {
self . mu . Lock ( )
defer self . mu . Unlock ( )
self . uncleMu . Lock ( )
defer self . uncleMu . Unlock ( )
self . currentMu . Lock ( )
defer self . currentMu . Unlock ( )
2015-06-15 02:33:08 -07:00
tstart := time . Now ( )
2015-06-16 03:41:50 -07:00
parent := self . chain . CurrentBlock ( )
tstamp := tstart . Unix ( )
2015-06-30 00:13:16 -07:00
if tstamp <= int64 ( parent . Time ( ) ) {
tstamp = int64 ( parent . Time ( ) ) + 1
2015-06-16 03:41:50 -07:00
}
2015-06-29 09:55:49 -07:00
// this will ensure we're not going off too far in the future
if now := time . Now ( ) . Unix ( ) ; tstamp > now + 4 {
wait := time . Duration ( tstamp - now ) * time . Second
glog . V ( logger . Info ) . Infoln ( "We are too far in the future. Waiting for" , wait )
time . Sleep ( wait )
}
2015-06-16 03:41:50 -07:00
num := parent . Number ( )
header := & types . Header {
ParentHash : parent . Hash ( ) ,
Number : num . Add ( num , common . Big1 ) ,
2015-06-30 00:13:16 -07:00
Difficulty : core . CalcDifficulty ( int64 ( tstamp ) , int64 ( parent . Time ( ) ) , parent . Difficulty ( ) ) ,
2015-06-16 03:41:50 -07:00
GasLimit : core . CalcGasLimit ( parent ) ,
GasUsed : new ( big . Int ) ,
Coinbase : self . coinbase ,
Extra : self . extra ,
Time : uint64 ( tstamp ) ,
}
2015-06-15 02:33:08 -07:00
2015-05-21 08:50:01 -07:00
previous := self . current
2015-06-16 03:41:50 -07:00
self . makeCurrent ( parent , header )
2015-05-10 16:28:15 -07:00
current := self . current
2015-02-04 05:52:59 -08:00
2015-06-16 03:41:50 -07:00
// commit transactions for this run.
2015-02-04 05:52:59 -08:00
transactions := self . eth . TxPool ( ) . GetTransactions ( )
sort . Sort ( types . TxByNonce { transactions } )
2015-06-16 03:41:50 -07:00
current . coinbase . SetGasLimit ( header . GasLimit )
current . commitTransactions ( transactions , self . gasPrice , self . proc )
2015-05-10 16:28:15 -07:00
self . eth . TxPool ( ) . RemoveTransactions ( current . lowGasTxs )
2015-02-04 05:52:59 -08:00
2015-06-16 03:41:50 -07:00
// compute uncles for the new block.
2015-03-23 10:27:05 -07:00
var (
uncles [ ] * types . Header
badUncles [ ] common . Hash
)
2015-03-23 04:12:49 -07:00
for hash , uncle := range self . possibleUncles {
2015-03-23 08:14:33 -07:00
if len ( uncles ) == 2 {
2015-03-23 04:12:49 -07:00
break
}
if err := self . commitUncle ( uncle . Header ( ) ) ; err != nil {
2015-04-15 03:12:20 -07:00
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 )
}
2015-03-23 10:27:05 -07:00
badUncles = append ( badUncles , hash )
2015-03-23 04:12:49 -07:00
} else {
2015-04-07 05:57:04 -07:00
glog . V ( logger . Debug ) . Infof ( "commiting %x as uncle\n" , hash [ : 4 ] )
2015-03-23 08:14:33 -07:00
uncles = append ( uncles , uncle . Header ( ) )
2015-03-23 04:12:49 -07:00
}
}
2015-03-23 10:27:05 -07:00
for _ , hash := range badUncles {
delete ( self . possibleUncles , hash )
}
2015-03-23 08:35:44 -07:00
2015-06-29 06:17:05 -07:00
if atomic . LoadInt32 ( & self . mining ) == 1 {
// commit state root after all state transitions.
core . AccumulateRewards ( self . current . state , header , uncles )
2015-07-01 03:07:14 -07:00
current . state . SyncObjects ( )
2015-06-29 09:55:49 -07:00
self . current . state . Sync ( )
2015-06-29 06:17:05 -07:00
header . Root = current . state . Root ( )
}
2015-03-23 04:12:49 -07:00
2015-06-16 03:41:50 -07:00
// create the new block whose nonce will be mined.
current . block = types . NewBlock ( header , current . txs , uncles , current . receipts )
2015-06-29 03:12:30 -07:00
self . current . block . Td = new ( big . Int ) . Set ( core . CalcTD ( self . current . block , self . chain . GetBlock ( self . current . block . ParentHash ( ) ) ) )
2015-02-04 05:52:59 -08:00
2015-06-16 03:41:50 -07:00
// 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 )
}
2015-04-07 03:32:55 -07:00
2015-02-09 07:20:34 -08:00
self . push ( )
2015-02-04 05:52:59 -08:00
}
func ( self * worker ) commitUncle ( uncle * types . Header ) error {
2015-06-16 03:41:50 -07:00
hash := uncle . Hash ( )
if self . current . uncles . Has ( hash ) {
2015-02-04 05:52:59 -08:00
return core . UncleError ( "Uncle not unique" )
}
2015-05-13 17:46:23 -07:00
if ! self . current . ancestors . Has ( uncle . ParentHash ) {
2015-02-04 05:52:59 -08:00
return core . UncleError ( fmt . Sprintf ( "Uncle's parent unknown (%x)" , uncle . ParentHash [ 0 : 4 ] ) )
}
2015-06-16 03:41:50 -07:00
if self . current . family . Has ( hash ) {
return core . UncleError ( fmt . Sprintf ( "Uncle already in family (%x)" , hash ) )
2015-02-04 05:52:59 -08:00
}
2015-06-15 02:33:08 -07:00
self . current . uncles . Add ( uncle . Hash ( ) )
2015-02-04 05:52:59 -08:00
return nil
}
2015-06-16 03:41:50 -07:00
func ( env * environment ) commitTransactions ( transactions types . Transactions , gasPrice * big . Int , proc * core . BlockProcessor ) {
2015-05-10 16:28:15 -07:00
for _ , tx := range transactions {
// We can skip err. It has already been validated in the tx pool
from , _ := tx . From ( )
2015-05-11 12:47:34 -07:00
// Check if it falls within margin. Txs from owned accounts are always processed.
2015-06-16 03:41:50 -07:00
if tx . GasPrice ( ) . Cmp ( gasPrice ) < 0 && ! env . ownedAccounts . Has ( from ) {
2015-05-10 16:28:15 -07:00
// ignore the transaction and transactor. We ignore the transactor
// because nonce will fail after ignoring this transaction so there's
// no point
2015-06-16 03:41:50 -07:00
env . lowGasTransactors . Add ( from )
2015-05-10 16:28:15 -07:00
2015-06-16 03:41:50 -07:00
glog . V ( logger . Info ) . Infof ( "transaction(%x) below gas price (tx=%v ask=%v). All sequential txs from this address(%x) will be ignored\n" , tx . Hash ( ) . Bytes ( ) [ : 4 ] , common . CurrencyToString ( tx . GasPrice ( ) ) , common . CurrencyToString ( gasPrice ) , from [ : 4 ] )
2015-05-10 16:28:15 -07:00
}
// Continue with the next transaction if the transaction sender is included in
// the low gas tx set. This will also remove the tx and all sequential transaction
// from this transactor
2015-06-16 03:41:50 -07:00
if env . lowGasTransactors . Has ( from ) {
2015-05-10 16:28:15 -07:00
// add tx to the low gas set. This will be removed at the end of the run
// owned accounts are ignored
2015-06-16 03:41:50 -07:00
if ! env . ownedAccounts . Has ( from ) {
env . lowGasTxs = append ( env . lowGasTxs , tx )
2015-05-10 16:28:15 -07:00
}
continue
}
// Move on to the next transaction when the transactor is in ignored transactions set
// This may occur when a transaction hits the gas limit. When a gas limit is hit and
// the transaction is processed (that could potentially be included in the block) it
// will throw a nonce error because the previous transaction hasn't been processed.
// Therefor we need to ignore any transaction after the ignored one.
2015-06-16 03:41:50 -07:00
if env . ignoredTransactors . Has ( from ) {
2015-05-10 16:28:15 -07:00
continue
}
2015-06-16 03:41:50 -07:00
env . state . StartRecord ( tx . Hash ( ) , common . Hash { } , 0 )
2015-05-10 16:28:15 -07:00
2015-06-16 03:41:50 -07:00
err := env . commitTransaction ( tx , proc )
2015-05-10 16:28:15 -07:00
switch {
case state . IsGasLimitErr ( err ) :
// ignore the transactor so no nonce errors will be thrown for this account
// next time the worker is run, they'll be picked up again.
2015-06-16 03:41:50 -07:00
env . ignoredTransactors . Add ( from )
2015-05-10 16:28:15 -07:00
glog . V ( logger . Detail ) . Infof ( "Gas limit reached for (%x) in this block. Continue to try smaller txs\n" , from [ : 4 ] )
2015-07-06 02:54:11 -07:00
case err != nil :
env . remove . Add ( tx . Hash ( ) )
if glog . V ( logger . Detail ) {
glog . Infof ( "TX (%x) failed, will be removed: %v\n" , tx . Hash ( ) . Bytes ( ) [ : 4 ] , err )
}
2015-05-10 16:28:15 -07:00
default :
2015-06-16 03:41:50 -07:00
env . tcount ++
2015-05-10 16:28:15 -07:00
}
}
}
2015-06-16 03:41:50 -07:00
func ( env * environment ) 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 )
2015-07-06 02:54:11 -07:00
if err != nil {
2015-06-16 03:41:50 -07:00
env . state . Set ( snap )
2015-02-04 05:52:59 -08:00
return err
}
2015-06-16 03:41:50 -07:00
env . txs = append ( env . txs , tx )
env . receipts = append ( env . receipts , receipt )
2015-02-04 05:52:59 -08:00
return nil
}
2015-02-28 14:09:49 -08:00
2015-05-13 18:39:07 -07:00
// TODO: remove or use
2015-02-28 14:09:49 -08:00
func ( self * worker ) HashRate ( ) int64 {
2015-05-13 18:39:07 -07:00
return 0
2015-02-28 14:09:49 -08:00
}
2015-05-09 03:13:46 -07:00
// gasprice calculates a reduced gas price based on the pct
// XXX Use big.Rat?
func gasprice ( price * big . Int , pct int64 ) * big . Int {
p := new ( big . Int ) . Set ( price )
p . Div ( p , big . NewInt ( 100 ) )
p . Mul ( p , big . NewInt ( pct ) )
return p
}
2015-05-10 14:12:18 -07:00
func accountAddressesSet ( accounts [ ] accounts . Account ) * set . Set {
accountSet := set . New ( )
for _ , account := range accounts {
2015-05-10 11:30:02 -07:00
accountSet . Add ( account . Address )
2015-05-10 14:12:18 -07:00
}
return accountSet
}