- func (s *Ethereum) StartMining(local bool) error {' F7 T F6 S) u( u4 w) `% W8 i
- eb, err := s.Etherbase()//用户地址
- if err != nil {
- log.Error("Cannot start mining without etherbase", "err", err)2 h* B. o. s: e1 ?
- return fmt.Errorf("etherbase missing: %v", err)
- }) e9 P6 U' F$ i0 m2 X
- if clique, ok := s.engine.(*clique.Clique); ok {
- //如果是clique共识算法& [7 v$ Q/ ^- B$ X: a( s! \4 s/ Z
- wallet, err := s.accountManager.Find(accounts.Account{Address: eb}) // 根据用它胡地址获取wallet对象, Q# W( w/ C; l% m! R) F
- if wallet == nil || err != nil {; E1 E! M6 c2 e# G
- log.Error("Etherbase account unavailable locally", "err", err); E, {- }0 B/ e+ ~+ j
- return fmt.Errorf("signer missing: %v", err)0 l, e* g4 p; C& e
- }
- clique.Authorize(eb, wallet.SignHash) // 注入签名者以及wallet对象获取签名方法; t y" E+ N( T, R, }2 M
- }
- if local {3 `2 _# u- Y9 \& e
- // 如果本地CPU已开始挖矿，我们可以禁用引入的交易拒绝机制来加速同步时间。CPU挖矿在主网是荒诞的，所以没有人能碰到这个路径，然而一旦CPU挖矿同步标志完成以后，将保证私网工作也在一个独立矿工结点。
- atomic.StoreUint32(&s.protocolManager.acceptTxs, 1)' w: y! p: I- t' F
- }
- go s.miner.Start(eb)
- return nil
- }
这个StartMining会在miner.start前调用，然后通过woker -> agent -> CPUAgent -> update -> seal 挖掘区块和组装（后面会写单独的文章来对挖矿过程做源码分析）。/ R! {% `: T* K+ O0 M
Clique的代码块在go-ethereum/consensus/clique路径下。和ethash一样，在clique.go 中实现了consensus的接口, consensus 定义了下面这些接口:
type Engine interface {
Author(header *types.Header) (common.Address, error)
VerifyHeader(chain ChainReader, header *types.Header, seal bool) error/ E- R6 G5 y! g8 [5 t/ ]% L; {4 J
VerifyHeaders(chain ChainReader, headers []*types.Header, seals []bool) (chan
Engine.Seal()函数可对一个调用过 Finalize()的区块进行授权或封印，成功时返回的区块全部成员齐整，可视为一个正常区块，可被广播到整个网络中，也可以被插入区块链等。对于挖掘一个新区块来说，所有相关代码里 Engine.Seal()是其中最重要最复杂的一步,所以这里我们首先来看下Clique 结构体：# ^) y" T2 C6 H" a7 `
- type Clique struct {
- config *params.CliqueConfig // 共识引擎配置参数
- db ethdb.Database // 数据库，用来存储和获取快照检查点
- recents *lru.ARCCache // 最近区块快照，加速快照重组
- signatures *lru.ARCCache // 最近区块签名，加速挖矿# t+ Q! A. L+ `3 u) ^& F
- proposals map[common.Address]bool // 目前正在推送的提案) P* j. r, H; I* _3 P& N1 W9 c
- signer common.Address // 签名者的以太坊地址
- signFn SignerFn // 授权哈希的签名方法
- lock sync.RWMutex // 用锁来保护签名字段
- }
顺便来看下CliqueConfig共识引擎的配置参数结构体:" r/ U6 _4 D# b5 D! U
- type CliqueConfig struct {
- Period uint64 `json:"period"` // 在区块之间执行的秒数（比如出块秒数15s）1 F4 `6 |) Z0 r. G: Y, e- T
- Epoch uint64 `json:"epoch"` // Epoch长度，重置投票和检查点（比如Epoch长度是30000个block, 每次进入新的epoch,前面的投票都被清空, 重新开始记录）
- }
在上面的 StartMining中，通过Clique. Authorize来注入签名者和签名方法，先来看下Authorize：
- func (c *Clique) Authorize(signer common.Address, signFn SignerFn) {
- c.lock.Lock()! J# E4 [! O" m, _4 t
- defer c.lock.Unlock()
- // 这个方法就是为clique共识注入一个签名者的私钥地址已经签名函数用来挖出新块: M0 D" `$ g2 q& V) v2 o9 B
- c.signer = signer
- c.signFn = signFn
- }
再来看Clique的Seal()函数的具体实现：
//通过本地签名认证创建已密封的区块
func (c *Clique) Seal(chain consensus.ChainReader, block *types.Block, stop number-limit {
log.Info("Signed recently, must wait for others")
- m3 S2 k' O' l' Y( A& f# c
Seal是共识引擎的入口之一，该函数通过clique.signer对区块签名
signer不在snapshot的signer中不允许签名
signer不是本区块的签名者需要延时随机一段时候后再签名，是本区块的签名者则直接签名
签名存放在Extra的extraSeal的65个字节中. ` y7 L" i8 Y+ {
关于机会均等 为了使得出块的负载（或者说是机会）对于每个认证节点尽量均等，同时避免某些恶意节点持续出块，clique中规定每一个认证节点在连续SIGNER_LIMIT个区块中，最多只能签发一个区块，也就是说，每一轮中，最多只有SIGNER_COUNT - SIGNER_LIMIT个认证节点可以参与区块签发。 其中SIGNER_LIMIT = floor(SIGNER_COUNT / 2) + 1，SIGNER_COUNT表示认证节点的个数。, _7 T3 R6 ^ H" a9 _
- //snap.Signers是所有的认证节点
- for seen, recent := range snap.Recents {; f5 S& C( _* z( W7 x. w
- if recent == signer {' s/ b" {+ \+ w, i8 B5 E( w" O$ x
- if limit := uint64(len(snap.Signers)/2 + 1); number number-limit {
- log.Info("Signed recently, must wait for others")
, w& N E# |$ ^6 W
在保证好节点的个数大于坏节点的前提下，好节点最少的个数为SIGNER_LIMIT（大于50%），坏节点最多的个数为SIGNER_COUNT - SIGNER_LIMIT（小于50%）。一个节点在SIGNER_LIMIT这个时间窗口内最多只能签发一个区块，这就使得恶意节点在不超过50%的情况下，从理论上无法一直掌握区块的签发权。6 A- K% N& q' D" i! e1 a: A
关于难度计算 为了让每个认证节点都有均等的机会去签发一个区块，每个节点在签发时都会判断本节点是不是本轮的inturn节点，若是inturn节点，则该节点产生的区块难度为2，否则为1。每一轮仅有一个节点为inturn节点。5 u& V6 V+ y% F, Q) {, |- U. n
diffInTurn = big.NewInt(2) 7 ?5 X7 t0 P G
diffNoTurn = big.NewInt(1)
当inturn的结点离线时，其他结点会来竞争，难度值降为1。然而正常出块时，limit中的所有认证结点包括一个inturn和其他noturn的结点，clique是采用了给noturn加延迟时间的方式来支持inturn首先出块，避免noturn的结点无谓生成区块，上面的延时代码段已经有提现了。 判断是否为inturn的节点，将本地维护的认证节点按照字典序排序，若当前区块号除以认证节点个数的余数等于该节点的下标，则该节点为inturn节点。代码实现在 snapshot.go中：4 ?( u5 X. l0 Z! E. [
// 通过给定的区块高度和签发者返回该签发者是否在轮次内) S; a0 F- u9 b: a
- func (s *Snapshot) inturn(number uint64, signer common.Address) bool {, y: A/ A; S7 R2 K ^) r
- signers, offset := s.signers(), 0
- for offset
Seal()代码中有获取快照，然后从快照中来检查授权区块签名者的逻辑，那么我们继续来看下Snapshot，首先看下Snapshot的结构体：
// Snapshot对象是在给定时间点的一个认证投票的状态
- type Snapshot struct {
- config *params.CliqueConfig // 共识引擎配置参数& A5 p0 y* h1 u4 {
- sigcache *lru.ARCCache // 签名缓存，最近的区块签名加速恢复。# [6 T$ P' y' }" k2 x$ T, f9 B
- Number uint64 `json:"number"` // 快照建立的区块号- n# y7 |& S+ ~8 S- O
- Hash common.Hash `json:"hash"` // 快照建立的区块哈希3 R, k8 z" F# n7 {4 ]& v
- Signers map[common.Address]struct{} `json:"signers"` // 当下认证签名者的列表6 J5 g7 `+ ~& Y
- Recents map[uint64]common.Address `json:"recents"` // 最近担当过数字签名算法的signer 的地址
- Votes []*Vote `json:"votes"` // 按时间顺序排列的投票名单。
- Tally map[common.Address]Tally `json:"tally"` // 当前的投票结果，避免重新计算。
- }
快照Snapshot对象中存在投票的Votes和记票的Tally对象:
- // Vote代表了一个独立的投票，这个投票可以授权一个签名者，更改授权列表。
- type Vote struct {
- Signer common.Address `json:"signer"` // 已授权的签名者（通过投票）1 w, a2 F+ v1 R% F* e* ~
- Block uint64 `json:"block"` // 投票区块号0 X1 z6 A& e( v5 H0 e! K N) a
- Address common.Address `json:"address"` // 被投票的账户，修改它的授权
- Authorize bool `json:"authorize"` // 对一个被投票账户是否授权或解授权2 x+ F& U8 q- |6 o! Q
- }" S# S# @" x w+ U
- // Tally是一个简单的用来保存当前投票分数的计分器
- type Tally struct {
- Authorize bool `json:"authorize"` // 授权true或移除false8 \9 }0 T/ N( g+ t$ |. ^
- Votes int `json:"votes"` // 该提案已获票数; {& E. V' M. T+ b: {
- }
Snapshot是一个快照，不仅是一个缓存，而且存储了最近签名者的map loadSnapshot用来从数据库中加载一个已存在的快照：
- func loadSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) {% T+ Q. p" t% n7 _" \& b
- //使用Database接口的Get方法通过Key来查询缓存内容0 W' j* k/ c ?: x0 V0 y
- blob, err := db.Get(append([]byte("clique-"), hash[:]...))
- if err != nil {: O7 Q5 G; V+ Q1 i4 c2 [$ x+ k
- return nil, err
- }
- snap := new(Snapshot)
- if err := json.Unmarshal(blob, snap); err != nil {$ c6 A% J8 ~# i& G* P% A$ Z# A' _: N
- return nil, err( a* o' X; d( p4 R7 H& i9 C5 Y
- }# X/ o) ^( p, M5 _. U: y
- snap.config = config
- snap.sigcache = sigcache
- return snap, nil
- }
newSnapshot函数用于创建快照，这个方法没有初始化最近的签名者集合，所以只使用创世块：
- func newSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, number uint64, hash common.Hash, signers []common.Address) *Snapshot {
- //组装一个Snapshot对象1 p( e% K) d& M& s4 w; U f' K
- snap := &Snapshot{2 g9 _" L E/ d6 s7 y
- config: config,
- sigcache: sigcache, ?$ o- V+ i7 ]" T
- Number: number,$ x8 R+ ]$ g3 A
- Hash: hash,
- Signers: make(map[common.Address]struct{}),2 d3 |3 n( F2 q6 m
- Recents: make(map[uint64]common.Address),; J z7 R4 O6 _) J+ q% a( x
- Tally: make(map[common.Address]Tally),0 S, R8 T$ k9 I
- }1 w( R* e3 a; z6 b% D" s2 S0 T0 \
- for _, signer := range signers {
- snap.Signers[signer] = struct{}{}
- }0 N. p d7 x6 D$ k5 J9 p; V+ p
- return snap' n8 ` a6 ^+ T
- }
继续看下snapshot函数的具体实现：
- // 快照会在给定的时间点检索授权快照
- func (c *Clique) snapshot(chain consensus.ChainReader, number uint64, hash common.Hash, parents []*types.Header) (*Snapshot, error) {
- // 在内存或者磁盘上查找一个快照来检查检查点checkpoints
- var (0 T5 d) s. X' q. F+ V- L
- headers []*types.Header //区块头! N$ l& n* j0 P
- snap *Snapshot //快照对象( y* @2 @4 `6 ~! d; z7 ]
- ), d* g, [! {/ v+ g+ a# b# z
- for snap == nil {
- // 如果在内存中找到快照时，快照对象从内存中取
- if s, ok := c.recents.Get(hash); ok {% u# q( m/ f' t! O& y
- snap = s.(*Snapshot)8 _" y+ s. l* |
- break3 `6 E+ Y! _7 ~
- }2 w, H& U/ ` f" o
- // 如果在磁盘检查点找到快照时
- if number%checkpointInterval == 0 { //checkpointInterval = 1024 表示投票快照保存到数据库的区块的区块号
- if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil {
- log.Trace("Loaded voting snapshot form disk", "number", number, "hash", hash)% ~1 _! B1 F9 _4 _
- snap = s
- break
- }
- }9 M; U' Q1 k9 m q6 G2 ]
- // 如果在创世块，则新建一个快照# M" S J. K/ O# M- D/ y+ Y3 N7 c4 w
- if number == 0 {
- genesis := chain.GetHeaderByNumber(0)/ ~& O1 |" _* ? x" ?
- if err := c.VerifyHeader(chain, genesis, false); err != nil {
- return nil, err
- }/ S; C5 @) Z) v
- signers := make([]common.Address, (len(genesis.Extra)-extraVanity-extraSeal)/common.AddressLength)1 ]( H$ X3 n5 F0 z. X* `- d
- for i := 0; i 0 {2 c, j: M9 M& s; ~
- // 如果我们有明确的父，从那里挑选（强制执行）8 ]1 i3 K3 ?+ {7 `8 m, G
- header = parents[len(parents)-1]0 w; m) W% b' l0 p9 W6 R9 i
- if header.Hash() != hash || header.Number.Uint64() != number {
- return nil, consensus.ErrUnknownAncestor. u# l5 A9 O& p- L
- }
- parents = parents[:len(parents)-1]# E j! D3 x" X7 Y, {+ F1 K# b- A$ V9 M
- } else {
- // 没有明确的父（或者没有更多的父）转到数据库获取
- header = chain.GetHeader(hash, number)
- if header == nil {
- return nil, consensus.ErrUnknownAncestor6 R+ D/ F; F2 x& J2 n
- }6 _% O) E- G* x% x5 e2 W
- }! M9 \$ ]) }' `
- headers = append(headers, header)7 |. K' V" A. X2 S+ v. g1 P
- number, hash = number-1, header.ParentHash
- }
- // 找到了之前的快照，将所有的pedding块头放在它上面
- for i := 0; i 0 {# J, R5 T/ C, Z2 l) |
- if err = snap.store(c.db); err != nil {
- return nil, err0 Z1 @' l& P4 n8 n3 q
- }4 u2 W7 d- K) y4 ~( n0 H
- log.Trace("Stored voting snapshot to disk", "number", snap.Number, "hash", snap.Hash)
- }
- return snap, err+ Q |% ~5 p9 y( R/ J
- }
在snapshot中，snap.apply通过区块头来创建一个新的快照，这个apply中主要做什么操作？6 M# N1 V% I$ @4 w
- //apply将给定的区块头应用于原始头来创建新的授权快照。+ f; `$ Z7 g O N# t
- func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {6 Y. p! R# J& c1 g+ H u4 l
- //可以传空区块头
- if len(headers) == 0 {3 R& G0 ]1 w, c& T! {6 s
- return s, nil
- }0 g* T) r$ [6 `6 p* i5 l/ V
- //完整性检查区块头可用性, ~& O& J' e* S# P; _9 f
- for i := 0; i = limit {
- delete(snap.Recents, number-limit)7 c1 ]6 U& J: c! {# u; S; v
- }
- // 从区块头中解密出来签名者地址
- signer, err := ecrecover(header, s.sigcache)
- if err != nil {6 d+ C' Q9 d: ?0 a( ]2 R* ~2 q# g
- return nil, err
- }
- if _, ok := snap.Signers[signer]; !ok {) ~6 j+ N" _5 t* O
- return nil, errUnauthorized
- }
- for _, recent := range snap.Recents { Q4 E' @! ^3 r/ c% }7 }: |
- if recent == signer {3 j' h! f& S7 K/ x* `
- return nil, errUnauthorized/ F: R1 Y* z9 g
- }
- }: W. ~" t. U' M) e
- snap.Recents[number] = signer8 M/ e- W. C6 Y0 R5 m5 n9 S, t$ D
- // 区块头认证，不管该签名者之前的任何投票0 G! m. @6 \" e% ~0 c' }+ C! V
- for i, vote := range snap.Votes {
- if vote.Signer == signer && vote.Address == header.Coinbase {
- // 从缓存计数器中移除该投票
- snap.uncast(vote.Address, vote.Authorize)
- // 从按时间排序的列表中移除投票
- snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...)
- break // 只允许一票
- }
- }+ R. ^8 [ G/ K$ ]* ^& G8 \
- // 从签名者中计数新的投票; V9 n" N) ^# r
- var authorize bool
- switch {
- case bytes.Equal(header.Nonce[:], nonceAuthVote):3 D5 ^! S2 H' O# m1 J0 K4 a
- authorize = true, w D) L) _+ _0 A1 Y3 K9 F
- case bytes.Equal(header.Nonce[:], nonceDropVote):
- authorize = false- X$ p+ n7 H/ P' `4 D
- default:
- return nil, errInvalidVote
- }
- if snap.cast(header.Coinbase, authorize) {
- snap.Votes = append(snap.Votes, &Vote{
- Signer: signer,$ [: W8 r5 t% C. I" S! g
- Block: number,
- Address: header.Coinbase,# y9 f1 T# d) L' f- M
- Authorize: authorize,, M0 T. t3 i# o Y
- })/ k# y) \1 x; c5 o' u- m
- }/ p9 t4 K* {4 T
- // 判断票数是否超过一半的投票者，如果投票通过，更新签名者列表: @5 f7 U+ ^3 ?% }
- if tally := snap.Tally[header.Coinbase]; tally.Votes > len(snap.Signers)/2 {. N8 c, | L, v0 f- ]
- if tally.Authorize {- h1 m# F1 ^# I
- snap.Signers[header.Coinbase] = struct{}{}
- } else {9 V! |4 o( F e; ^
- delete(snap.Signers, header.Coinbase)
- // 签名者列表缩减，删除最近剩余的缓存" b" R3 j. F/ j$ ~ @5 e7 U! }3 o
- if limit := uint64(len(snap.Signers)/2 + 1); number >= limit {
- delete(snap.Recents, number-limit)
- }& R$ j7 S9 x, T& y9 m: x, [+ s0 X
- for i := 0; i
Snapshot.apply()方法的主要部分是迭代处理每个header对象，首先从数字签名中恢复出签名所用公钥，转化为common.Address类型，作为signer地址。数字签名(signagure)长度65 bytes，存放在Header.Extra[]的末尾。如果signer地址是尚未认证的，则直接退出本次迭代；如果是已认证的，则投票+1。所以一个父区块可添加一张记名投票，signer作为投票方地址，Header.Coinbase作为被投票地址，投票内容authorized可由Header.Nonce取值确定。更新投票统计信息。如果被投票地址的总投票次数达到已认证地址个数的一半，则通过之。该被投票地址的认证状态立即被更改，根据是何种更改，相应的更新缓存数据，并删除过时的投票信息。在所有Header对象都被处理完后，Snapshot内部的Number，Hash值会被更新，表明当前Snapshot快照结构已经更新到哪个区块了。. d! J$ L% V p( x
区块验证的过程是普通节点在收到一个新区块时，会从区块头的extraData字段中取出认证节点的签名，利用标准的spec256k1椭圆曲线进行反解公钥信息，并且从公钥中截取出签发节点的地址，若该节点是认证节点，且该节点本轮拥有签名的权限，则认为该区块为合法区块。verifySeal是被SubmitWork(miner/remote_agent.go) 来调用，SubmitWork函数尝试注入一个pow解决方案（共识引擎）到远程代理，返回这个解决方案是否被接受。（不能同时是一个坏的pow也不能有其他任何错误，例如没有工作被pending）解决方案有效时，返回到矿工并且通知接受结果。
- // 检查包头中包含的签名是否满足共识协议要求。该方法接受一个可选的父头的列表，这些父头还不是本地区块链的一部分，用于生成快照
- func (c *Clique) verifySeal(chain consensus.ChainReader, header *types.Header, parents []*types.Header) error {
- // 不支持校检创世块
- number := header.Number.Uint64()
- if number == 0 {: i9 w" n, I Z: S' F5 j
- return errUnknownBlock3 W5 E' d1 M/ Q6 Q+ U2 t' ]; ~
- }+ P! h: j8 N3 b2 K
- // 检索出所需的区块对象来校检去开头和将其缓存; ]. n. \& f3 _" H8 Z% o& y$ m
- snap, err := c.snapshot(chain, number-1, header.ParentHash, parents)
- if err != nil {
- return err; S( ~6 E* [. i/ o$ i
- }1 Z& L! V* S5 |1 e1 ?! H
- //解析授权密钥并检查签署者，ecrecover方法从区块头中反解出Extra字段中签名字符串来获取签名者地址 t" x& E. X" g& A5 N' Z" U% t
- signer, err := ecrecover(header, c.signatures)! r- N- v2 V2 `) r
- if err != nil {7 g* u) t& t- W$ o" o4 A& I& Z+ Z' k
- return err
- }
- if _, ok := snap.Signers[signer]; !ok {
- return errUnauthorized. u# x& D/ S9 v4 H( d5 C) P
- }) @; U8 m6 f f p. z
- for seen, recent := range snap.Recents {
- if recent == signer {
- // 签署者是最近的，只有当前块没有移出时才会失败，参见seal中的机会均等
- if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit {
- return errUnauthorized
- }
- }
- }) o; {0 m5 A& U+ f" b O
- // 设置区块难度，参见上面的区块难度部分( S x/ M, R. ]# r7 W2 E$ g
- inturn := snap.inturn(header.Number.Uint64(), signer)1 [7 g* h& J% |2 ?, m
- if inturn && header.Difficulty.Cmp(diffInTurn) != 0 {3 G/ Y* D6 C. _; O: M$ `2 d
- return errInvalidDifficulty
- }* h7 i* F$ K9 d2 m& U3 [0 K8 q
- if !inturn && header.Difficulty.Cmp(diffNoTurn) != 0 {, ?6 S# l2 _2 e Q! L$ o6 u" x
- return errInvalidDifficulty0 o# m7 p2 f( W( A+ Q" h) S1 V& \
- }
- return nil
- }
前面已经分析了Clique的认证节点的出块和校检的过程，那么如何来区分一个节点是认证节点还是一个普通节点？以及一个授权者列表是如何产生并如何全网同步的？
Clique通过投票机制来确认一个认证节点，投票的范围在委员会中，委员会就是所有节点矿工集合，普通节点没有区块生成权利。矿工的投票流程如下：. J, S q+ g6 P
委员会节点通过RPC调用Propose，对某节点状态变更，从普通节点变成认证阶段，或者相反，写入到Clique.purposal集合中
- // Propose注入一个新的授权提案，可以授权一个签名者或者移除一个。
- func (api *API) Propose(address common.Address, auth bool) {+ h& p9 q. r4 E3 D4 k% G! w
- api.clique.lock.Lock()/ ?. y: Z2 S: q3 X7 r- J
- defer api.clique.lock.Unlock()
- api.clique.proposals[address] = auth// true:授权，false:移除
- }
本地认证节点在一次区块打包的过程中，从purposal池中随机挑选一条还未被应用的purposal，并将信息填入区块头，将区块广播给其他节点；7 T/ Z0 p( _# O3 T: s, G# u% y& m
- //Clique.Prepare
- // 抓取所有有意义投票的提案
- addresses := make([]common.Address, 0, len(c.proposals))# E+ ?0 ~7 V8 o* ^
- for address, authorize := range c.proposals {4 z' ?3 h" n3 h* K' X# t
- if snap.validVote(address, authorize) {+ y1 _% B5 M5 G* S' N F2 [( P
- addresses = append(addresses, address)
- }* T' ?: X9 I* ] T w0 e
- }" m8 t) h( Z8 z" j5 f' Z/ ~! x
- // If there's pending proposals, cast a vote on them0 s. H' ?! I$ ?2 }0 K: K! O7 t
- if len(addresses) > 0 {* G0 r9 P, \& f# R0 E* w
- header.Coinbase = addresses[rand.Intn(len(addresses))] //随机挑选一条投票节点的地址赋值给区块头的Coinbase字段。( E* w! J. ~1 P) A. _0 H
- // 通过提案内容来组装区块头的随机数字段。" Y* }* g/ }- l
- if c.proposals[header.Coinbase] {
- copy(header.Nonce[:], nonceAuthVote)" R3 o9 c# Q& o& k- [; m$ q
- } else { D% [! I5 }6 m! `. r+ ]
- copy(header.Nonce[:], nonceDropVote)
- } T/ r M# a/ R1 u* Y
- }
在挖矿开始以后，会在miner.start()中提交一个commitNewWork，其中调用上面Prepare) \/ \! K) G4 U8 ?& r
- if err := self.engine.Prepare(self.chain, header); err != nil {
- log.Error("Failed to prepare header for mining", "err", err)
- return8 M1 T R! D" }1 x r$ j, k3 v! O7 {
- }
其他节点在接收到区块后，取出其中的信息，封装成一个vote进行存储，并将投票结果应用到本地，若关于目标节点的状态更改获得的一致投票超过1/2，则更改目标节点的状态：若为新增认证节点，将目标节点的地址添加到本地的认证节点的列表中；若为删除认证节点，将目标节点的地址从本地的认证节点列表中删除。具体实现可以查看上面的Snapshot.apply()方法
: }" B( N7 S$ u2 H w @/ }- r
" k$ g! r7 j( I7 }: p, z! h ^- \. B" ?
以太坊中除了基于运算能力的POW(Ethash)外，还有基于权利证明的POA共识机制，Clique是以太坊的POA共识算法的实现，这里主要对POA的Clique相关源码做一个解读分析。
