- func (s *Ethereum) StartMining(local bool) error {, L" ?& ?% m3 A6 W; a5 `: W3 ]9 t
- eb, err := s.Etherbase()//用户地址
- if err != nil {
- log.Error("Cannot start mining without etherbase", "err", err)& G; r. ^" b* ^+ p: H; k
- return fmt.Errorf("etherbase missing: %v", err)
- }
- if clique, ok := s.engine.(*clique.Clique); ok {3 h8 E% q- A `# M- ?
- //如果是clique共识算法" T! W# h% k& q/ \' T2 L
- wallet, err := s.accountManager.Find(accounts.Account{Address: eb}) // 根据用它胡地址获取wallet对象, l8 Q" Z! j9 E1 y; B" n6 H
- if wallet == nil || err != nil {/ K# i* a9 f6 }
- log.Error("Etherbase account unavailable locally", "err", err): T* e2 K! G( Y. u) t8 |3 Z
- return fmt.Errorf("signer missing: %v", err)
- }
- clique.Authorize(eb, wallet.SignHash) // 注入签名者以及wallet对象获取签名方法8 W8 F# S9 ]+ R" ~7 T9 t
- }
- if local {/ u' Z/ ^& U! D6 y
- // 如果本地CPU已开始挖矿，我们可以禁用引入的交易拒绝机制来加速同步时间。CPU挖矿在主网是荒诞的，所以没有人能碰到这个路径，然而一旦CPU挖矿同步标志完成以后，将保证私网工作也在一个独立矿工结点。
- atomic.StoreUint32(&s.protocolManager.acceptTxs, 1)
- }
- go s.miner.Start(eb)
- return nil: M* I) |! a* n' i
- }
这个StartMining会在miner.start前调用，然后通过woker -> agent -> CPUAgent -> update -> seal 挖掘区块和组装（后面会写单独的文章来对挖矿过程做源码分析）。
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
VerifyHeaders(chain ChainReader, headers []*types.Header, seals []bool) (chan
Engine.Seal()函数可对一个调用过 Finalize()的区块进行授权或封印，成功时返回的区块全部成员齐整，可视为一个正常区块，可被广播到整个网络中，也可以被插入区块链等。对于挖掘一个新区块来说，所有相关代码里 Engine.Seal()是其中最重要最复杂的一步,所以这里我们首先来看下Clique 结构体：/ L, ~' S# E& N, B* B! c/ ~. ]
- type Clique struct {
- config *params.CliqueConfig // 共识引擎配置参数6 A0 b$ z5 P* Z4 I
- db ethdb.Database // 数据库，用来存储和获取快照检查点
- recents *lru.ARCCache // 最近区块快照，加速快照重组
- signatures *lru.ARCCache // 最近区块签名，加速挖矿
- proposals map[common.Address]bool // 目前正在推送的提案1 s+ S8 U, J6 V9 _3 U: M, ?0 ]
- signer common.Address // 签名者的以太坊地址( d+ p; V, d( |) j/ u, E l. x
- signFn SignerFn // 授权哈希的签名方法
- lock sync.RWMutex // 用锁来保护签名字段" h3 _7 \8 L+ ^
- }
顺便来看下CliqueConfig共识引擎的配置参数结构体:& S- p, `- X6 K2 ~, d
- type CliqueConfig struct {
- Period uint64 `json:"period"` // 在区块之间执行的秒数（比如出块秒数15s）
- Epoch uint64 `json:"epoch"` // Epoch长度，重置投票和检查点（比如Epoch长度是30000个block, 每次进入新的epoch,前面的投票都被清空, 重新开始记录）2 D/ ~1 l; w4 D9 t
- }
在上面的 StartMining中，通过Clique. Authorize来注入签名者和签名方法，先来看下Authorize：: w0 P/ z0 w* h5 R( ^+ R7 p
- func (c *Clique) Authorize(signer common.Address, signFn SignerFn) {+ Y5 |4 X! d- l* Q/ `) x
- c.lock.Lock()
- defer c.lock.Unlock()! X$ L& ^, g: u, }7 f
- // 这个方法就是为clique共识注入一个签名者的私钥地址已经签名函数用来挖出新块7 D6 _3 O% p, ?8 \- o. H2 w7 n/ {& A
- c.signer = signer/ o P, ]- [) l! L" j) h/ b- T
- c.signFn = signFn
- }
再来看Clique的Seal()函数的具体实现：
//通过本地签名认证创建已密封的区块1 _) h* A8 r, z0 H, m/ K8 u! a1 \
func (c *Clique) Seal(chain consensus.ChainReader, block *types.Block, stop number-limit {4 c5 V3 v! Z5 L- W; @0 \4 q0 |$ A
log.Info("Signed recently, must wait for others")1 `; }2 \6 I# a, W) |( W# `
7 X$ H9 w; h% x$ h* F
Seal是共识引擎的入口之一，该函数通过clique.signer对区块签名
signer不在snapshot的signer中不允许签名
signer不是本区块的签名者需要延时随机一段时候后再签名，是本区块的签名者则直接签名
签名存放在Extra的extraSeal的65个字节中
关于机会均等 为了使得出块的负载（或者说是机会）对于每个认证节点尽量均等，同时避免某些恶意节点持续出块，clique中规定每一个认证节点在连续SIGNER_LIMIT个区块中，最多只能签发一个区块，也就是说，每一轮中，最多只有SIGNER_COUNT - SIGNER_LIMIT个认证节点可以参与区块签发。 其中SIGNER_LIMIT = floor(SIGNER_COUNT / 2) + 1，SIGNER_COUNT表示认证节点的个数。
- //snap.Signers是所有的认证节点
- for seen, recent := range snap.Recents {0 u- |; L) m/ {3 u/ ^$ P
- if recent == signer {
- if limit := uint64(len(snap.Signers)/2 + 1); number number-limit {$ n. W2 ^$ @: i: i! R: X& d
- log.Info("Signed recently, must wait for others")
$ G* q3 ]9 P1 b8 S0 x
在保证好节点的个数大于坏节点的前提下，好节点最少的个数为SIGNER_LIMIT（大于50%），坏节点最多的个数为SIGNER_COUNT - SIGNER_LIMIT（小于50%）。一个节点在SIGNER_LIMIT这个时间窗口内最多只能签发一个区块，这就使得恶意节点在不超过50%的情况下，从理论上无法一直掌握区块的签发权。
关于难度计算 为了让每个认证节点都有均等的机会去签发一个区块，每个节点在签发时都会判断本节点是不是本轮的inturn节点，若是inturn节点，则该节点产生的区块难度为2，否则为1。每一轮仅有一个节点为inturn节点。
diffInTurn = big.NewInt(2) ' P; B& ^7 m+ I1 u$ y) q
diffNoTurn = big.NewInt(1)
当inturn的结点离线时，其他结点会来竞争，难度值降为1。然而正常出块时，limit中的所有认证结点包括一个inturn和其他noturn的结点，clique是采用了给noturn加延迟时间的方式来支持inturn首先出块，避免noturn的结点无谓生成区块，上面的延时代码段已经有提现了。 判断是否为inturn的节点，将本地维护的认证节点按照字典序排序，若当前区块号除以认证节点个数的余数等于该节点的下标，则该节点为inturn节点。代码实现在 snapshot.go中：
// 通过给定的区块高度和签发者返回该签发者是否在轮次内
- func (s *Snapshot) inturn(number uint64, signer common.Address) bool {% l: f0 ]; U& @7 O0 ]& P
- signers, offset := s.signers(), 0
- for offset
Seal()代码中有获取快照，然后从快照中来检查授权区块签名者的逻辑，那么我们继续来看下Snapshot，首先看下Snapshot的结构体：; G7 f( B$ l) Q& ~
// Snapshot对象是在给定时间点的一个认证投票的状态
- type Snapshot struct {: `3 _ l3 z5 J' Q: c
- config *params.CliqueConfig // 共识引擎配置参数
- sigcache *lru.ARCCache // 签名缓存，最近的区块签名加速恢复。; X# i* [8 o# ^' E
- Number uint64 `json:"number"` // 快照建立的区块号
- Hash common.Hash `json:"hash"` // 快照建立的区块哈希
- Signers map[common.Address]struct{} `json:"signers"` // 当下认证签名者的列表5 `/ k; ]) F$ s2 E# H
- Recents map[uint64]common.Address `json:"recents"` // 最近担当过数字签名算法的signer 的地址; {' u: \5 y) A* E* b
- Votes []*Vote `json:"votes"` // 按时间顺序排列的投票名单。
- Tally map[common.Address]Tally `json:"tally"` // 当前的投票结果，避免重新计算。2 e7 f e. K! o( H( M0 f
- }
快照Snapshot对象中存在投票的Votes和记票的Tally对象:
- // Vote代表了一个独立的投票，这个投票可以授权一个签名者，更改授权列表。1 s& j$ I5 I3 k1 ^0 q8 }2 a
- type Vote struct {) T6 U, r: q# m) x3 E7 V% j7 l3 X: M
- Signer common.Address `json:"signer"` // 已授权的签名者（通过投票）
- Block uint64 `json:"block"` // 投票区块号
- Address common.Address `json:"address"` // 被投票的账户，修改它的授权' p$ L! h2 K _$ W8 ~7 a" B* A! m
- Authorize bool `json:"authorize"` // 对一个被投票账户是否授权或解授权
- }
- // Tally是一个简单的用来保存当前投票分数的计分器( e. g- a. F5 N" K D
- type Tally struct {
- Authorize bool `json:"authorize"` // 授权true或移除false# r* V/ K- f+ K0 E. b" S ^, M
- Votes int `json:"votes"` // 该提案已获票数
- }
Snapshot是一个快照，不仅是一个缓存，而且存储了最近签名者的map loadSnapshot用来从数据库中加载一个已存在的快照：
- func loadSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) {, m9 r1 x- z/ |% R# A8 i$ L1 C
- //使用Database接口的Get方法通过Key来查询缓存内容8 H! n& \5 g9 I: }7 D4 I/ H2 \
- blob, err := db.Get(append([]byte("clique-"), hash[:]...))# q! |& N* F. G2 H- Q
- if err != nil {
- return nil, err, W5 A7 F- Q3 o; z% h! Q: O6 J
- }
- snap := new(Snapshot)8 E" _; x* V/ P. T# Y+ a
- if err := json.Unmarshal(blob, snap); err != nil {
- return nil, err
- }/ G4 ~/ p2 H7 {% F+ V0 k' n8 Q
- snap.config = config% a+ J! k; m v1 v% o( z
- snap.sigcache = sigcache
- return snap, nil
- }
newSnapshot函数用于创建快照，这个方法没有初始化最近的签名者集合，所以只使用创世块：3 \' \/ z9 I P0 O, G7 c5 T' w
- func newSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, number uint64, hash common.Hash, signers []common.Address) *Snapshot {
- //组装一个Snapshot对象( M$ I9 C* U/ P0 d1 J! t }
- snap := &Snapshot{- O) p4 x& | j+ W2 i) m
- config: config,
- sigcache: sigcache,: q( U- Q( l7 h- x. O$ K- d
- Number: number,! J. p1 n; e6 m* c1 m) P
- Hash: hash,4 L" O! x$ ]0 q% a( _1 t
- Signers: make(map[common.Address]struct{}),5 F8 ?9 |7 g3 r& M3 c9 c5 e/ K7 T
- Recents: make(map[uint64]common.Address), f) p U- ?9 M- _
- Tally: make(map[common.Address]Tally),
- }
- for _, signer := range signers {1 Y6 r/ N& x. J# I! Y% R5 S
- snap.Signers[signer] = struct{}{}6 w: @0 Q! y$ h
- }
- return snap
- }
继续看下snapshot函数的具体实现：
- // 快照会在给定的时间点检索授权快照4 R# T3 f a J
- func (c *Clique) snapshot(chain consensus.ChainReader, number uint64, hash common.Hash, parents []*types.Header) (*Snapshot, error) {5 X4 X9 Q* F" i$ @6 q0 A
- // 在内存或者磁盘上查找一个快照来检查检查点checkpoints6 \- h/ A P4 n9 ]3 H4 ^
- var (% E2 X6 g2 S/ J4 E9 r# c m
- headers []*types.Header //区块头
- snap *Snapshot //快照对象- g, ?6 K" M8 a7 ^8 F4 H! X6 _/ b
- )
- for snap == nil {
- // 如果在内存中找到快照时，快照对象从内存中取
- if s, ok := c.recents.Get(hash); ok {/ O3 }3 Q- i: `; P
- snap = s.(*Snapshot)
- break5 ?5 K3 l3 `! ]9 n% D/ F! P+ _
- }, }& H- h. o! p1 ~" z6 i/ D5 L
- // 如果在磁盘检查点找到快照时+ D9 f, y) r( j$ @
- if number%checkpointInterval == 0 { //checkpointInterval = 1024 表示投票快照保存到数据库的区块的区块号( E0 l3 z3 N( q q0 Q+ N0 r
- if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil { @! Y. a3 ]- v
- log.Trace("Loaded voting snapshot form disk", "number", number, "hash", hash)% L2 U0 p9 n! O! b' R- M
- snap = s
- break/ [- w8 d, u6 j& Q. [
- }
- }2 D& d/ v, z+ R6 ^
- // 如果在创世块，则新建一个快照
- if number == 0 {& I& G* _ U& \7 }1 ?2 Y0 j
- genesis := chain.GetHeaderByNumber(0)
- if err := c.VerifyHeader(chain, genesis, false); err != nil {! x8 [! P# g& y1 K
- return nil, err" n* F P; J+ t, Y# |0 ]# |0 ~
- }
- signers := make([]common.Address, (len(genesis.Extra)-extraVanity-extraSeal)/common.AddressLength)% k0 g- _ Y1 P( o% ]# O
- for i := 0; i 0 {* l0 e+ }4 K- n f \* e0 B7 Z
- // 如果我们有明确的父，从那里挑选（强制执行）& @6 d9 y& f/ J- `. q# `
- header = parents[len(parents)-1]
- if header.Hash() != hash || header.Number.Uint64() != number { `6 ?' p+ ^9 v- p- J2 R/ V) K
- return nil, consensus.ErrUnknownAncestor
- }
- parents = parents[:len(parents)-1]) O D: s/ m( @" [+ ^. I0 n
- } else {
- // 没有明确的父（或者没有更多的父）转到数据库获取
- header = chain.GetHeader(hash, number)2 z3 s- o- H/ a' i- n) E" X
- if header == nil {
- return nil, consensus.ErrUnknownAncestor
- }
- }* {2 ^* m0 U, g8 t6 ?5 Q
- headers = append(headers, header)
- number, hash = number-1, header.ParentHash
- }
- // 找到了之前的快照，将所有的pedding块头放在它上面9 O- I* R2 b5 `/ `9 r& m
- for i := 0; i 0 {( v- B$ m4 [! t2 u: q n
- if err = snap.store(c.db); err != nil {0 p6 _( h6 r6 p' ?2 y: ^. a$ g
- return nil, err
- }
- log.Trace("Stored voting snapshot to disk", "number", snap.Number, "hash", snap.Hash). e7 O5 A( E- B3 g- i2 V
- } v9 [: z* q7 W! B" ?& h
- return snap, err
- }
在snapshot中，snap.apply通过区块头来创建一个新的快照，这个apply中主要做什么操作？0 \/ B2 A! q: h. z8 r
- //apply将给定的区块头应用于原始头来创建新的授权快照。
- func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {) Z3 P* B- f3 u3 W: r3 W
- //可以传空区块头
- if len(headers) == 0 {& P$ e9 A" S# d0 f u
- return s, nil' W" Z$ e7 o I; i. T
- }9 g ]! e; U; m6 e# X3 _
- //完整性检查区块头可用性
- for i := 0; i = limit {
- delete(snap.Recents, number-limit)1 x7 s1 E* t, f+ z2 b, C
- }
- // 从区块头中解密出来签名者地址
- signer, err := ecrecover(header, s.sigcache)
- if err != nil {
- return nil, err
- }% F' d; }" q y5 j' I% u" W @
- if _, ok := snap.Signers[signer]; !ok {
- return nil, errUnauthorized8 p6 _# W1 }8 d. U% x1 W$ ?
- }1 v) `/ Z5 L( @5 ^/ B5 [
- for _, recent := range snap.Recents {
- if recent == signer {' s) J( w% g$ o% ?' K3 T' }
- return nil, errUnauthorized
- }: D# A, B: M$ F/ k! F/ m
- }" X$ O& ]4 _6 ?
- snap.Recents[number] = signer
- // 区块头认证，不管该签名者之前的任何投票9 `/ s" v: p" J. z9 r
- for i, vote := range snap.Votes {( ^8 ^# v, Z, a5 ?* p
- 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 // 只允许一票+ p% p) f; ]6 e
- }
- }
- // 从签名者中计数新的投票
- var authorize bool
- switch {
- case bytes.Equal(header.Nonce[:], nonceAuthVote):
- authorize = true- `1 s/ X! B% s; B) d
- case bytes.Equal(header.Nonce[:], nonceDropVote):
- authorize = false+ P8 c& c' m1 Z9 L' J1 P
- default:
- return nil, errInvalidVote+ d1 s' U% ] b+ T* h8 C
- }
- if snap.cast(header.Coinbase, authorize) {
- snap.Votes = append(snap.Votes, &Vote{# A6 k0 N+ X, Q
- Signer: signer,$ Y# d3 P3 S+ c3 Y: T. Z! y/ t
- Block: number,' T) c& r* X7 u/ m0 K
- Address: header.Coinbase,
- Authorize: authorize,, j3 l6 l; f1 r$ V/ D
- })
- }8 y; f& F+ k/ P7 S/ L
- // 判断票数是否超过一半的投票者，如果投票通过，更新签名者列表
- if tally := snap.Tally[header.Coinbase]; tally.Votes > len(snap.Signers)/2 {% a, h1 u% ]" T$ R) f R, |2 Q" a
- if tally.Authorize {( V1 x6 ~) j0 s0 [
- snap.Signers[header.Coinbase] = struct{}{}0 X! J9 S& @2 J' k; P
- } else {
- delete(snap.Signers, header.Coinbase)& o. |, Z( a0 L+ D9 |- v
- // 签名者列表缩减，删除最近剩余的缓存
- if limit := uint64(len(snap.Signers)/2 + 1); number >= limit {9 V" z6 W+ J% y: v F' y) H
- delete(snap.Recents, number-limit); ]% |0 i t6 d) V/ Q+ c4 Z0 Q
- }
- 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快照结构已经更新到哪个区块了。
区块验证的过程是普通节点在收到一个新区块时，会从区块头的extraData字段中取出认证节点的签名，利用标准的spec256k1椭圆曲线进行反解公钥信息，并且从公钥中截取出签发节点的地址，若该节点是认证节点，且该节点本轮拥有签名的权限，则认为该区块为合法区块。verifySeal是被SubmitWork(miner/remote_agent.go) 来调用，SubmitWork函数尝试注入一个pow解决方案（共识引擎）到远程代理，返回这个解决方案是否被接受。（不能同时是一个坏的pow也不能有其他任何错误，例如没有工作被pending）解决方案有效时，返回到矿工并且通知接受结果。
- // 检查包头中包含的签名是否满足共识协议要求。该方法接受一个可选的父头的列表，这些父头还不是本地区块链的一部分，用于生成快照7 ] \3 B! F) u! v, B
- func (c *Clique) verifySeal(chain consensus.ChainReader, header *types.Header, parents []*types.Header) error {& J9 r7 J; X( G- d% G! _
- // 不支持校检创世块4 r6 M5 N4 d" O: e0 Q( j2 V7 c
- number := header.Number.Uint64()
- if number == 0 {2 B# z3 K* S+ b2 L, L3 G
- return errUnknownBlock
- }
- // 检索出所需的区块对象来校检去开头和将其缓存0 @' @" d5 `" ?6 F5 k& L6 P6 B' W
- snap, err := c.snapshot(chain, number-1, header.ParentHash, parents)2 [: g3 @" X/ e$ T7 O1 l
- if err != nil {
- return err
- }
- //解析授权密钥并检查签署者，ecrecover方法从区块头中反解出Extra字段中签名字符串来获取签名者地址) K& f0 M# r! K$ D3 K6 J, A
- signer, err := ecrecover(header, c.signatures)
- if err != nil {) H& Q) ]$ Q& C' D
- return err
- }2 ^0 w! a* x% o4 G' y
- if _, ok := snap.Signers[signer]; !ok {) c Q7 l: {3 G/ B" J9 `
- return errUnauthorized7 _0 r) d2 w5 m, w8 m4 f" @! E
- }
- for seen, recent := range snap.Recents {
- if recent == signer {7 }9 ^; F A6 F% @' L. I6 i/ I
- // 签署者是最近的，只有当前块没有移出时才会失败，参见seal中的机会均等$ w) O% n1 D: @, L
- if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit {
- return errUnauthorized7 |3 C" r/ F/ O( g w
- }: w. `1 y' a+ D6 u
- }
- }8 K0 |$ b0 Z+ Q. u, d
- // 设置区块难度，参见上面的区块难度部分
- inturn := snap.inturn(header.Number.Uint64(), signer)6 }5 @% { R8 J: L+ D% r; _
- if inturn && header.Difficulty.Cmp(diffInTurn) != 0 {
- return errInvalidDifficulty0 |2 l2 |; A: z9 V3 ^1 D! u
- }$ c# F& ?$ Z% C
- if !inturn && header.Difficulty.Cmp(diffNoTurn) != 0 {
- return errInvalidDifficulty
- }
- return nil3 ^ u% X8 t& e! h. X
- }
前面已经分析了Clique的认证节点的出块和校检的过程，那么如何来区分一个节点是认证节点还是一个普通节点？以及一个授权者列表是如何产生并如何全网同步的？
Clique通过投票机制来确认一个认证节点，投票的范围在委员会中，委员会就是所有节点矿工集合，普通节点没有区块生成权利。矿工的投票流程如下：1 x: d0 p. T* B+ ]/ C2 U
委员会节点通过RPC调用Propose，对某节点状态变更，从普通节点变成认证阶段，或者相反，写入到Clique.purposal集合中, s" G6 D/ M5 w. c
- // Propose注入一个新的授权提案，可以授权一个签名者或者移除一个。
- func (api *API) Propose(address common.Address, auth bool) {
- api.clique.lock.Lock()' q2 ?) c& p( S" T I
- defer api.clique.lock.Unlock()
- api.clique.proposals[address] = auth// true:授权，false:移除3 O! z2 a% g* f% ]3 E
- }
本地认证节点在一次区块打包的过程中，从purposal池中随机挑选一条还未被应用的purposal，并将信息填入区块头，将区块广播给其他节点；
- //Clique.Prepare
- // 抓取所有有意义投票的提案
- addresses := make([]common.Address, 0, len(c.proposals))& r7 v* C. F$ z, A' q: S, M
- for address, authorize := range c.proposals {% c) U& w6 s/ p; B6 C8 W7 f8 Y, h! _
- if snap.validVote(address, authorize) {
- addresses = append(addresses, address)7 D5 P5 h+ [ O- E
- }
- }( B, W' `, D$ `
- // If there's pending proposals, cast a vote on them
- if len(addresses) > 0 {
- header.Coinbase = addresses[rand.Intn(len(addresses))] //随机挑选一条投票节点的地址赋值给区块头的Coinbase字段。
- // 通过提案内容来组装区块头的随机数字段。
- if c.proposals[header.Coinbase] {
- copy(header.Nonce[:], nonceAuthVote)3 i* D6 v: ~5 C ^3 @$ }) K
- } else {
- copy(header.Nonce[:], nonceDropVote)% t+ h' P) P0 `2 C. i
- }
- }
在挖矿开始以后，会在miner.start()中提交一个commitNewWork，其中调用上面Prepare" g D8 }- u, ]+ o, i) S
- if err := self.engine.Prepare(self.chain, header); err != nil {0 q8 E6 Q1 q% ? N5 ~3 [) V; I
- log.Error("Failed to prepare header for mining", "err", err)
- return
- }
其他节点在接收到区块后，取出其中的信息，封装成一个vote进行存储，并将投票结果应用到本地，若关于目标节点的状态更改获得的一致投票超过1/2，则更改目标节点的状态：若为新增认证节点，将目标节点的地址添加到本地的认证节点的列表中；若为删除认证节点，将目标节点的地址从本地的认证节点列表中删除。具体实现可以查看上面的Snapshot.apply()方法7 O3 R4 u5 _& Y. i/ y
' U* r7 V+ n2 s2 b5 r; F! {
0 _& n$ Z k7 b( c2 ]4 ~" }
以太坊中除了基于运算能力的POW(Ethash)外，还有基于权利证明的POA共识机制，Clique是以太坊的POA共识算法的实现，这里主要对POA的Clique相关源码做一个解读分析。
