我们都知道从比特币开始，我们将打包出一个合法区块的节点叫做Miner(矿工)，同时将这个过程叫做Mining(挖矿)。这个比喻是很贴切的，因为无论是Bitcoin还是Eth其代币数量都是有限的，就像地球上的黄金储备量，你从金矿挖出一点其储备就会少一点。

wiki关于挖矿的描述这里就不再赘述。我们直捣黄龙开撸源码！！！

Miner结构

// Miner creates blocks and searches for proof-of-work values.
type Miner struct {
    // 事件锁
    mux *event.TypeMux

    // 真正干活的人
    worker *worker
    // 矿工地址
    coinbase common.Address
    // 表示正在挖矿的状态
    mining   int32
    // Backend对象，Backend是一个自定义接口封装了所有挖矿所需方法
    eth      Backend
    // 共识引擎 以太坊有两种共识引擎ethash和clique
    engine   consensus.Engine

    // 是否能够开始挖矿
    canStart    int32 // can start indicates whether we can start the mining operation
    // 同步后是否应该开始挖矿
    shouldStart int32 // should start indicates whether we should start after sync
}

miner只是以太坊对外实现mining功能的开放类，真正干活的是worker。所以，继续深入看看worker的结构。

// worker is the main object which takes care of applying messages to the new state
type worker struct {
    // 链的配置属性
    config *params.ChainConfig
    // 前面提到的共识引擎
    engine consensus.Engine
    // 同步锁
    mu sync.Mutex

    // update loop
    mux          *event.TypeMux
    txsCh        chan core.NewTxsEvent
    txsSub       event.Subscription
    chainHeadCh  chan core.ChainHeadEvent
    chainHeadSub event.Subscription
    chainSideCh  chan core.ChainSideEvent
    chainSideSub event.Subscription
    wg           sync.WaitGroup

    // Agent的map集合
    agents map[Agent]struct{}
    recv   chan *Result

    eth     Backend
    chain   *core.BlockChain
    proc    core.Validator
    chainDb ethdb.Database

    coinbase common.Address
    extra    []byte

    currentMu sync.Mutex
    current   *Work

    snapshotMu    sync.RWMutex
    snapshotBlock *types.Block
    snapshotState *state.StateDB

    uncleMu        sync.Mutex
    possibleUncles map[common.Hash]*types.Block

    // 本地挖出的有待确认的区块
    unconfirmed *unconfirmedBlocks // set of locally mined blocks pending canonicalness confirmations

    // atomic status counters
    mining int32
    atWork int32
}

这里，我们来着重看一下params.ChainConfig这个结构，顾名思义，它是链的配置属性，其中定义了一些针对以太坊历史问题的相关配置。

// ChainConfig is stored in the database on a per block basis. This means
// that any network, identified by its genesis block, can have its own
// set of configuration options.
type ChainConfig struct {
    // 标识当前链，主键唯一id 也用来防止replay attack重放攻击
    ChainID *big.Int `json:"chainId"` // chainId identifies the current chain and is used for replay protection
    // 以太坊发展蓝图中的一个阶段,当前阶段为Homestead
    // 第一阶段为以太坊面世代号frontier，第二阶段为Homestead即当前阶段
    // 第三阶段为Metropolis(大都会)，Metropolis又分为Byzantium(拜占庭硬分叉，引入新型零知识证明算法和pos共识)，
    // 然后是constantinople(君士坦丁堡硬分叉，eth正是应用pow和pos混合链)
    // 第四阶段为Serenity(宁静)，最终稳定版的以太坊
    HomesteadBlock *big.Int `json:"homesteadBlock,omitempty"` // Homestead switch block (nil = no fork, 0 = already homestead)

    // TheDao硬分叉切换，2017年6月18日应对DAO危机做出的调整
    DAOForkBlock   *big.Int `json:"daoForkBlock,omitempty"`   // TheDAO hard-fork switch block (nil = no fork)
    // 节点是否支持TheDao硬分叉
    DAOForkSupport bool     `json:"daoForkSupport,omitempty"` // Whether the nodes supports or opposes the DAO hard-fork

    // EIP150 implements the Gas price changes (https://github.com/ethereum/EIPs/issues/150)
    // eth改善方案硬分叉  没有硬分叉的置0
    EIP150Block *big.Int    `json:"eip150Block,omitempty"` // EIP150 HF block (nil = no fork)
    EIP150Hash  common.Hash `json:"eip150Hash,omitempty"`  // EIP150 HF hash (needed for header only clients as only gas pricing changed)

    EIP155Block *big.Int `json:"eip155Block,omitempty"` // EIP155 HF block
    EIP158Block *big.Int `json:"eip158Block,omitempty"` // EIP158 HF block

    ByzantiumBlock      *big.Int `json:"byzantiumBlock,omitempty"`      // Byzantium switch block (nil = no fork, 0 = already on byzantium)
    ConstantinopleBlock *big.Int `json:"constantinopleBlock,omitempty"` // Constantinople switch block (nil = no fork, 0 = already activated)

    // Various consensus engines
    Ethash *EthashConfig `json:"ethash,omitempty"`
    Clique *CliqueConfig `json:"clique,omitempty"`
}

接着在worker里有一个agent代理，他们的关系应该是这样的。一个miner有一个worker，一个worker又同时拥有多个agent。这里的单个agent可以完成单个区块的mining，worker的多个agent间应该是竞争关系。

// Agent can register themself with the worker
type Agent interface {
    Work() chan<- *Work
    SetReturnCh(chan<- *Result)
    Stop()
    Start()
    GetHashRate() int64
}

Agent接口的定义下面又有一个work结构，work主要用来表示挖掘一个区块时候所需要的数据环境。

// Work is the workers current environment and holds
// all of the current state information
type Work struct {
    // 链的配置属性
    config *params.ChainConfig
    signer types.Signer

    // 数据库状态
    state     *state.StateDB // apply state changes here
    // 祖先集，用来验证叔父块有效性
    ancestors *set.Set       // ancestor set (used for checking uncle parent validity)
    // 家庭集，用来验证叔块无效
    family    *set.Set       // family set (used for checking uncle invalidity)
    // 叔块集
    uncles    *set.Set       // uncle set
    // 交易量
    tcount    int            // tx count in cycle
    // 用于打包交易的可用天然气
    gasPool   *core.GasPool  // available gas used to pack transactions
    
    // 新区快
    Block *types.Block // the new block

    // 区块头
    header   *types.Header
    txs      []*types.Transaction
    receipts []*types.Receipt

    createdAt time.Time
}

这里有两个类实现了agent接口，分别是CpuAgent和RemoteAgent。CpuAgent是用cpu进行挖矿操作，RemoteAgent是远程挖矿，它提供了一套RPC接口来实现远程矿工进行采矿的功能。

type CpuAgent struct {
    // 同步锁
    mu sync.Mutex

    // work通道
    workCh        chan *Work
    // 结构体通道对象
    stop          chan struct{}
    quitCurrentOp chan struct{}
    // Result指针通道
    returnCh      chan<- *Result

    // 共识引擎
    chain  consensus.ChainReader
    engine consensus.Engine

    // 当前agent是否在挖矿
    isMining int32 // isMining indicates whether the agent is currently mining
}
...
type RemoteAgent struct {
    mu sync.Mutex

    quitCh   chan struct{}
    workCh   chan *Work
    returnCh chan<- *Result

    chain       consensus.ChainReader
    engine      consensus.Engine
    currentWork *Work
    work        map[common.Hash]*Work

    hashrateMu sync.RWMutex
    hashrate   map[common.Hash]hashrate

    running int32 // running indicates whether the agent is active. Call atomically
}

挖矿逻辑

开始挖矿首先要实例化一个miner对象。

// 创建miner对象
func New(eth Backend, config *params.ChainConfig, mux *event.TypeMux, engine consensus.Engine) *Miner {
    miner := &Miner{
        eth:      eth,
        mux:      mux,
        engine:   engine,
        // 创建一个worker
        worker:   newWorker(config, engine, common.Address{}, eth, mux),
        canStart: 1,
    }
    // 注册newCpuAgent对象
    miner.Register(NewCpuAgent(eth.BlockChain(), engine))
    go miner.update()

    return miner
}

接着为实例化的miner对象创建一个worker对象来真正地干活。

// 为miner创建worker
func newWorker(config *params.ChainConfig, engine consensus.Engine, coinbase common.Address, eth Backend, mux *event.TypeMux) *worker {
    worker := &worker{
        config:         config,
        engine:         engine,
        eth:            eth,
        mux:            mux,
        // NewTxsEvent面熟吧，前面讲交易时 TxPool会发出该事件，当一笔交易被放入到交易池
        // 这时候如果work空闲会把Tx放到work.txs准备下一次打包进块
        txsCh:          make(chan core.NewTxsEvent, txChanSize),
        // ChainHeadEvent事件，表示已经有一个块作为链头 work.ipdate监听到该事件会继续挖矿
        chainHeadCh:    make(chan core.ChainHeadEvent, chainHeadChanSize),
        // ChainSideEvent事件，表示一个新块作为链的旁支可能会被放入possibleUncles中
        chainSideCh:    make(chan core.ChainSideEvent, chainSideChanSize),
        // 区块链数据库
        chainDb:        eth.ChainDb(),

        recv:           make(chan *Result, resultQueueSize),
        chain:          eth.BlockChain(),
        proc:           eth.BlockChain().Validator(),
        // 可能的叔块
        possibleUncles: make(map[common.Hash]*types.Block),
        coinbase:       coinbase,
        agents:         make(map[Agent]struct{}),
        // 挖出的未被确认的区块
        unconfirmed:    newUnconfirmedBlocks(eth.BlockChain(), miningLogAtDepth),
    }
    // Subscribe NewTxsEvent for tx pool
    worker.txsSub = eth.TxPool().SubscribeNewTxsEvent(worker.txsCh)
    // Subscribe events for blockchain
    worker.chainHeadSub = eth.BlockChain().SubscribeChainHeadEvent(worker.chainHeadCh)
    worker.chainSideSub = eth.BlockChain().SubscribeChainSideEvent(worker.chainSideCh)
    go worker.update()

    go worker.wait()
    worker.commitNewWork()

    return worker
}

从上面看出，worker.update方法来处理上述几个event事件。我们上次分析交易模块时对交易的提交也是在这处理的。

那么新区块的写入是在哪操作的呢？我们来来看worker.wait便能看出点端倪。

func (self *worker) wait() {
    for {
        for result := range self.recv {
            atomic.AddInt32(&self.atWork, -1)

            if result == nil {
                continue
            }
            block := result.Block
            work := result.Work

            // Update the block hash in all logs since it is now available and not when the
            // receipt/log of individual transactions were created.
            // 更新所有日志的块哈希
            for _, r := range work.receipts {
                for _, l := range r.Logs {
                    l.BlockHash = block.Hash()
                }
            }
            for _, log := range work.state.Logs() {
                log.BlockHash = block.Hash()
            }
            stat, err := self.chain.WriteBlockWithState(block, work.receipts, work.state)
            if err != nil {
                log.Error("Failed writing block to chain", "err", err)
                continue
            }
            // Broadcast the block and announce chain insertion event
            // 广播新区块并宣布链插入事件
            self.mux.Post(core.NewMinedBlockEvent{Block: block})
            var (
                events []interface{}
                logs   = work.state.Logs()
            )
            events = append(events, core.ChainEvent{Block: block, Hash: block.Hash(), Logs: logs})

            if stat == core.CanonStatTy {
                events = append(events, core.ChainHeadEvent{Block: block})
            }

            self.chain.PostChainEvents(events, logs)

            // Insert the block into the set of pending ones to wait for confirmations
            // 将数据插入待处理块中，等待确认
            self.unconfirmed.Insert(block.NumberU64(), block.Hash())
        }
    }
}

接着回到miner的创建，在创建完worker后，会为worker注册agent。

func NewCpuAgent(chain consensus.ChainReader, engine consensus.Engine) *CpuAgent {
    miner := &CpuAgent{
        chain:  chain,
        engine: engine,
        stop:   make(chan struct{}, 1),
        workCh: make(chan *Work, 1),
    }
    return miner
}
...
func (self *Miner) Register(agent Agent) {
    if self.Mining() {
        agent.Start()
    }
    self.worker.register(agent)
}
...
func (self *worker) register(agent Agent) {
    self.mu.Lock()
    defer self.mu.Unlock()
    self.agents[agent] = struct{}{}
    agent.SetReturnCh(self.recv)
}

接下来在miner.update方法中开始挖矿。

// update keeps track of the downloader events. Please be aware that this is a one shot type of update loop.
// It's entered once and as soon as `Done` or `Failed` has been broadcasted the events are unregistered and
// the loop is exited. This to prevent a major security vuln where external parties can DOS you with blocks
// and halt your mining operation for as long as the DOS continues.
// update会跟踪下载程序事件。 请注意，这是一次性更新循环。
// 一旦广播“完成”或“失败”，事件就会被取消注册并退出循环。
// 这可以防止主要的安全漏洞，外部各方可以使用块来阻止你
// 并且只要DOS继续就停止你的挖掘操作
func (self *Miner) update() {
    events := self.mux.Subscribe(downloader.StartEvent{}, downloader.DoneEvent{}, downloader.FailedEvent{})
out:
    for ev := range events.Chan() {
        switch ev.Data.(type) {
        // 下载开始
        case downloader.StartEvent:
            atomic.StoreInt32(&self.canStart, 0)
            if self.Mining() {
                self.Stop()
                atomic.StoreInt32(&self.shouldStart, 1)
                log.Info("Mining aborted due to sync")
            }
            // 下载完成或失败
        case downloader.DoneEvent, downloader.FailedEvent:
            shouldStart := atomic.LoadInt32(&self.shouldStart) == 1

            atomic.StoreInt32(&self.canStart, 1)
            atomic.StoreInt32(&self.shouldStart, 0)
            if shouldStart {
                // 开始挖矿
                self.Start(self.coinbase)
            }
            // unsubscribe. we're only interested in this event once
            events.Unsubscribe()
            // stop immediately and ignore all further pending events
            break out
        }
    }
}
...
func (self *Miner) Start(coinbase common.Address) {
    atomic.StoreInt32(&self.shouldStart, 1)
    self.SetEtherbase(coinbase)

    if atomic.LoadInt32(&self.canStart) == 0 {
        log.Info("Network syncing, will start miner afterwards")
        return
    }
    atomic.StoreInt32(&self.mining, 1)

    log.Info("Starting mining operation")
    // 真正开始挖矿
    self.worker.start()
    self.worker.commitNewWork()
}

worker.start()函数表示，真正进行挖矿的是worker。继续深入到对应代码。

func (self *worker) start() {
    self.mu.Lock()
    defer self.mu.Unlock()

    atomic.StoreInt32(&self.mining, 1)

    // spin up agents
    // 遍历所有的agent，通知agent开始挖矿
    for agent := range self.agents {
        agent.Start()
    }
}

然后，还不是真正挖矿的代码。还得继续深入虎穴来探究agent内部的start。

func (self *CpuAgent) Start() {
    if !atomic.CompareAndSwapInt32(&self.isMining, 0, 1) {
        return // agent already started
    }
    go self.update()
}

func (self *CpuAgent) update() {
out:
    for {
        select {
        // 检测是否有工作信号进入
        case work := <-self.workCh:
            self.mu.Lock()
            if self.quitCurrentOp != nil {
                close(self.quitCurrentOp)
            }
            self.quitCurrentOp = make(chan struct{})
            go self.mine(work, self.quitCurrentOp)
            self.mu.Unlock()
            // 监测停止信号
        case <-self.stop:
            self.mu.Lock()
            if self.quitCurrentOp != nil {
                close(self.quitCurrentOp)
                self.quitCurrentOp = nil
            }
            self.mu.Unlock()
            break out
        }
    }
}

func (self *CpuAgent) mine(work *Work, stop <-chan struct{}) {

    // 通过共识引擎算法来挖矿
    if result, err := self.engine.Seal(self.chain, work.Block, stop); result != nil {
        log.Info("Successfully sealed new block", "number", result.Number(), "hash", result.Hash())
        self.returnCh <- &Result{work, result}
    } else {
        if err != nil {
            log.Warn("Block sealing failed", "err", err)
        }
        self.returnCh <- nil
    }
}

这里，agent.update和miner.update逻辑类似。好在这里终于看到了最终挖矿时通过agent封装的共识引擎来实现的。

其次，还有一个worker. commitNewWork()方法，它主要完成待挖掘区块的数据组装。

// 完成待挖掘区块的数据组装
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()

    tstart := time.Now()
    parent := self.chain.CurrentBlock()

    tstamp := tstart.Unix()
    if parent.Time().Cmp(new(big.Int).SetInt64(tstamp)) >= 0 {
        tstamp = parent.Time().Int64() + 1
    }
    // this will ensure we're not going off too far in the future
    // 确保新区块的产生不会花费太多时间
    if now := time.Now().Unix(); tstamp > now+1 {
        wait := time.Duration(tstamp-now) * time.Second
        log.Info("Mining too far in the future", "wait", common.PrettyDuration(wait))
        time.Sleep(wait)
    }

    // 组装区块头信息
    num := parent.Number()
    header := &types.Header{
        ParentHash: parent.Hash(),
        Number:     num.Add(num, common.Big1),
        GasLimit:   core.CalcGasLimit(parent),
        Extra:      self.extra,
        Time:       big.NewInt(tstamp),
    }
    // Only set the coinbase if we are mining (avoid spurious block rewards)
    // 如果正在挖掘，设置coinbase
    if atomic.LoadInt32(&self.mining) == 1 {
        header.Coinbase = self.coinbase
    }
    // 确保区块头信息准备好
    if err := self.engine.Prepare(self.chain, header); err != nil {
        log.Error("Failed to prepare header for mining", "err", err)
        return
    }
    // If we are care about TheDAO hard-fork check whether to override the extra-data or not
    // TheDAO硬分叉相关设置
    if daoBlock := self.config.DAOForkBlock; daoBlock != nil {
        // Check whether the block is among the fork extra-override range
        limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange)
        // 根据新区块Number判断是否受TheDAO硬分叉的影响
        if header.Number.Cmp(daoBlock) >= 0 && header.Number.Cmp(limit) < 0 {
            // Depending whether we support or oppose the fork, override differently
            if self.config.DAOForkSupport {
                // 支持TheDAO硬分叉
                header.Extra = common.CopyBytes(params.DAOForkBlockExtra)
            } else if bytes.Equal(header.Extra, params.DAOForkBlockExtra) {
                header.Extra = []byte{} // If miner opposes, don't let it use the reserved extra-data
            }
        }
    }
    // Could potentially happen if starting to mine in an odd state.
    err := self.makeCurrent(parent, header)
    if err != nil {
        log.Error("Failed to create mining context", "err", err)
        return
    }
    // Create the current work task and check any fork transitions needed
    // 创建当前所需的工作环境work
    work := self.current
    // 给work设置相关硬分叉设置
    if self.config.DAOForkSupport && self.config.DAOForkBlock != nil && self.config.DAOForkBlock.Cmp(header.Number) == 0 {
        misc.ApplyDAOHardFork(work.state)
    }
    // 准备新区块的交易列表
    pending, err := self.eth.TxPool().Pending()
    if err != nil {
        log.Error("Failed to fetch pending transactions", "err", err)
        return
    }
    // 交易按价格和nonce值排序
    txs := types.NewTransactionsByPriceAndNonce(self.current.signer, pending)
    // 提交交易
    work.commitTransactions(self.mux, txs, self.chain, self.coinbase)

    // compute uncles for the new block.
    // 为新的区块计算叔块
    var (
        uncles    []*types.Header
        badUncles []common.Hash
    )
    for hash, uncle := range self.possibleUncles {
        if len(uncles) == 2 {
            break
        }
        if err := self.commitUncle(work, uncle.Header()); err != nil {
            log.Trace("Bad uncle found and will be removed", "hash", hash)
            log.Trace(fmt.Sprint(uncle))

            badUncles = append(badUncles, hash)
        } else {
            log.Debug("Committing new uncle to block", "hash", hash)
            uncles = append(uncles, uncle.Header())
        }
    }
    for _, hash := range badUncles {
        delete(self.possibleUncles, hash)
    }
    // Create the new block to seal with the consensus engine
    // 使用共识引擎对新区块进行赋值，包括Header.Root, TxHash, ReceiptHash, UncleHash几个属性
    if work.Block, err = self.engine.Finalize(self.chain, header, work.state, work.txs, uncles, work.receipts); err != nil {
        log.Error("Failed to finalize block for sealing", "err", err)
        return
    }
    // We only care about logging if we're actually mining.
    if atomic.LoadInt32(&self.mining) == 1 {
        log.Info("Commit new mining work", "number", work.Block.Number(), "txs", work.tcount, "uncles", len(uncles), "elapsed", common.PrettyDuration(time.Since(tstart)))
        self.unconfirmed.Shift(work.Block.NumberU64() - 1)
    }
    // 加载工作环境
    self.push(work)
    self.updateSnapshot()
}

总结下思路，首先挖矿这里又三个角色：miner，worker和agent。miner是以太坊封装的对外的挖矿接口，worker是给miner干活的，agent是真正实现挖矿的东东。一个miner都会有一个worker属性，一个worker又有多个agent来通过共识引擎实现真正挖矿，这里还有个work来存储挖矿所需要的数据环境。

当要开始挖矿时，miner会创建一个worker，并为之注册对应的agent。然后worker将一个work对象发送给agent，所有的agent根据共识引擎来挖矿，当一个agent完成mine时会将一个授权的block加上对应的work组成一个result对象返回给worker。

挖矿逻辑的源码就看完了，明天来继续看看关于agent挖矿到底是怎么实现共识的(ethash算法)。

更多以太坊源码解析请移驾全球最大同性交友网,觉得有用记得给个小star哦😯😯😯

.
.
.
.

互联网颠覆世界，区块链颠覆互联网!

--------------------------------------------------20181012 01:09