Hi Guest

More contents, please log on!

Bitmere.com 区块链技术 Content

以太坊POA共识机制Clique源码分析

卫蒙更夜沙
2333 1 0
Clique的初始化在 Ethereum.StartMining中,如果Ethereum.engine配置为clique.Clique, 根据当前节点的矿工地址(默认是acounts[0]), 配置clique的 签名者 : clique.Authorize(eb, wallet.SignHash) ,其中签名函数是SignHash,对给定的hash进行签名。
  1. func (s *Ethereum) StartMining(local bool) error {
  2.         eb, err := s.Etherbase()//用户地址
  3.         if err != nil {
  4.                 log.Error("Cannot start mining without etherbase", "err", err)
  5.                 return fmt.Errorf("etherbase missing: %v", err)
  6.         }
  7.         if clique, ok := s.engine.(*clique.Clique); ok {
  8.                 //如果是clique共识算法
  9.                 wallet, err := s.accountManager.Find(accounts.Account{Address: eb})        // 根据用它胡地址获取wallet对象
  10.                 if wallet == nil || err != nil {
  11.                         log.Error("Etherbase account unavailable locally", "err", err)
  12.                         return fmt.Errorf("signer missing: %v", err)
  13.                 }
  14.                 clique.Authorize(eb, wallet.SignHash) // 注入签名者以及wallet对象获取签名方法
  15.         }
  16.         if local {
  17.                 // 如果本地CPU已开始挖矿,我们可以禁用引入的交易拒绝机制来加速同步时间。CPU挖矿在主网是荒诞的,所以没有人能碰到这个路径,然而一旦CPU挖矿同步标志完成以后,将保证私网工作也在一个独立矿工结点。
  18.                 atomic.StoreUint32(&s.protocolManager.acceptTxs, 1)
  19.         }
  20.         go s.miner.Start(eb)
  21.         return nil
  22. }
Copy the Code

这个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 结构体:
  1. type Clique struct {
  2.         config *params.CliqueConfig // 共识引擎配置参数
  3.         db     ethdb.Database       // 数据库,用来存储和获取快照检查点
  4.         recents    *lru.ARCCache // 最近区块快照,加速快照重组
  5.         signatures *lru.ARCCache // 最近区块签名,加速挖矿
  6.         proposals map[common.Address]bool // 目前正在推送的提案
  7.         signer common.Address // 签名者的以太坊地址
  8.         signFn SignerFn       // 授权哈希的签名方法
  9.         lock   sync.RWMutex   // 用锁来保护签名字段
  10. }
Copy the Code

顺便来看下CliqueConfig共识引擎的配置参数结构体:
  1. type CliqueConfig struct {
  2.     Period uint64 `json:"period"` // 在区块之间执行的秒数(比如出块秒数15s)
  3.     Epoch  uint64 `json:"epoch"`  // Epoch长度,重置投票和检查点(比如Epoch长度是30000个block, 每次进入新的epoch,前面的投票都被清空, 重新开始记录)
  4. }
Copy the Code

在上面的 StartMining中,通过Clique. Authorize来注入签名者和签名方法,先来看下Authorize:
  1. func (c *Clique) Authorize(signer common.Address, signFn SignerFn) {
  2.     c.lock.Lock()
  3.     defer c.lock.Unlock()
  4.     // 这个方法就是为clique共识注入一个签名者的私钥地址已经签名函数用来挖出新块
  5.     c.signer = signer
  6.     c.signFn = signFn
  7. }
Copy the Code

再来看Clique的Seal()函数的具体实现:
//通过本地签名认证创建已密封的区块
func (c *Clique) Seal(chain consensus.ChainReader, block *types.Block, stop  number-limit {
                                log.Info("Signed recently, must wait for others")
                                
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表示认证节点的个数。
  1. //snap.Signers是所有的认证节点
  2. for seen, recent := range snap.Recents {
  3.     if recent == signer {
  4.         if limit := uint64(len(snap.Signers)/2 + 1); number  number-limit {
  5.             log.Info("Signed recently, must wait for others")
Copy the Code

            
在保证好节点的个数大于坏节点的前提下,好节点最少的个数为SIGNER_LIMIT(大于50%),坏节点最多的个数为SIGNER_COUNT - SIGNER_LIMIT(小于50%)。一个节点在SIGNER_LIMIT这个时间窗口内最多只能签发一个区块,这就使得恶意节点在不超过50%的情况下,从理论上无法一直掌握区块的签发权。
关于难度计算 为了让每个认证节点都有均等的机会去签发一个区块,每个节点在签发时都会判断本节点是不是本轮的inturn节点,若是inturn节点,则该节点产生的区块难度为2,否则为1。每一轮仅有一个节点为inturn节点。
diffInTurn = big.NewInt(2)
diffNoTurn = big.NewInt(1)
当inturn的结点离线时,其他结点会来竞争,难度值降为1。然而正常出块时,limit中的所有认证结点包括一个inturn和其他noturn的结点,clique是采用了给noturn加延迟时间的方式来支持inturn首先出块,避免noturn的结点无谓生成区块,上面的延时代码段已经有提现了。 判断是否为inturn的节点,将本地维护的认证节点按照字典序排序,若当前区块号除以认证节点个数的余数等于该节点的下标,则该节点为inturn节点。代码实现在 snapshot.go中:
// 通过给定的区块高度和签发者返回该签发者是否在轮次内
  1. func (s *Snapshot) inturn(number uint64, signer common.Address) bool {
  2.         signers, offset := s.signers(), 0
  3.         for offset
Copy the Code

Seal()代码中有获取快照,然后从快照中来检查授权区块签名者的逻辑,那么我们继续来看下Snapshot,首先看下Snapshot的结构体:
// Snapshot对象是在给定时间点的一个认证投票的状态
  1. type Snapshot struct {
  2.     config   *params.CliqueConfig // 共识引擎配置参数
  3.     sigcache *lru.ARCCache        // 签名缓存,最近的区块签名加速恢复。
  4.     Number  uint64                      `json:"number"`  // 快照建立的区块号
  5.     Hash    common.Hash                 `json:"hash"`    // 快照建立的区块哈希
  6.     Signers map[common.Address]struct{} `json:"signers"` // 当下认证签名者的列表
  7.     Recents map[uint64]common.Address   `json:"recents"` // 最近担当过数字签名算法的signer 的地址
  8.     Votes   []*Vote                     `json:"votes"`   // 按时间顺序排列的投票名单。
  9.     Tally   map[common.Address]Tally    `json:"tally"`   // 当前的投票结果,避免重新计算。
  10. }
Copy the Code

快照Snapshot对象中存在投票的Votes和记票的Tally对象:
  1. // Vote代表了一个独立的投票,这个投票可以授权一个签名者,更改授权列表。
  2. type Vote struct {
  3.     Signer    common.Address `json:"signer"`    // 已授权的签名者(通过投票)
  4.     Block     uint64         `json:"block"`     // 投票区块号
  5.     Address   common.Address `json:"address"`   // 被投票的账户,修改它的授权
  6.     Authorize bool           `json:"authorize"` // 对一个被投票账户是否授权或解授权
  7. }
  8. // Tally是一个简单的用来保存当前投票分数的计分器
  9. type Tally struct {
  10.     Authorize bool `json:"authorize"` // 授权true或移除false
  11.     Votes     int  `json:"votes"`     // 该提案已获票数
  12. }
Copy the Code

Snapshot是一个快照,不仅是一个缓存,而且存储了最近签名者的map loadSnapshot用来从数据库中加载一个已存在的快照:
  1. func loadSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, db ethdb.Database, hash common.Hash) (*Snapshot, error) {
  2.         //使用Database接口的Get方法通过Key来查询缓存内容
  3.         blob, err := db.Get(append([]byte("clique-"), hash[:]...))
  4.         if err != nil {
  5.                 return nil, err
  6.         }
  7.         snap := new(Snapshot)
  8.         if err := json.Unmarshal(blob, snap); err != nil {
  9.                 return nil, err
  10.         }
  11.         snap.config = config
  12.         snap.sigcache = sigcache
  13.         return snap, nil
  14. }
Copy the Code

newSnapshot函数用于创建快照,这个方法没有初始化最近的签名者集合,所以只使用创世块:
  1. func newSnapshot(config *params.CliqueConfig, sigcache *lru.ARCCache, number uint64, hash common.Hash, signers []common.Address) *Snapshot {
  2.         //组装一个Snapshot对象
  3.         snap := &Snapshot{
  4.                 config:   config,
  5.                 sigcache: sigcache,
  6.                 Number:   number,
  7.                 Hash:     hash,
  8.                 Signers:  make(map[common.Address]struct{}),
  9.                 Recents:  make(map[uint64]common.Address),
  10.                 Tally:    make(map[common.Address]Tally),
  11.         }
  12.         for _, signer := range signers {
  13.                 snap.Signers[signer] = struct{}{}
  14.         }
  15.         return snap
  16. }
Copy the Code

继续看下snapshot函数的具体实现:
  1. // 快照会在给定的时间点检索授权快照
  2. func (c *Clique) snapshot(chain consensus.ChainReader, number uint64, hash common.Hash, parents []*types.Header) (*Snapshot, error) {
  3.         // 在内存或者磁盘上查找一个快照来检查检查点checkpoints
  4.         var (
  5.                 headers []*types.Header        //区块头
  6.                 snap    *Snapshot        //快照对象
  7.         )
  8.         for snap == nil {
  9.                 // 如果在内存中找到快照时,快照对象从内存中取
  10.                 if s, ok := c.recents.Get(hash); ok {
  11.                         snap = s.(*Snapshot)
  12.                         break
  13.                 }
  14.                 // 如果在磁盘检查点找到快照时
  15.                 if number%checkpointInterval == 0 { //checkpointInterval = 1024 表示投票快照保存到数据库的区块的区块号
  16.                         if s, err := loadSnapshot(c.config, c.signatures, c.db, hash); err == nil {
  17.                                 log.Trace("Loaded voting snapshot form disk", "number", number, "hash", hash)
  18.                                 snap = s
  19.                                 break
  20.                         }
  21.                 }
  22.                 // 如果在创世块,则新建一个快照
  23.                 if number == 0 {
  24.                         genesis := chain.GetHeaderByNumber(0)
  25.                         if err := c.VerifyHeader(chain, genesis, false); err != nil {
  26.                                 return nil, err
  27.                         }
  28.                         signers := make([]common.Address, (len(genesis.Extra)-extraVanity-extraSeal)/common.AddressLength)
  29.                         for i := 0; i  0 {
  30.                         // 如果我们有明确的父,从那里挑选(强制执行)
  31.                         header = parents[len(parents)-1]
  32.                         if header.Hash() != hash || header.Number.Uint64() != number {
  33.                                 return nil, consensus.ErrUnknownAncestor
  34.                         }
  35.                         parents = parents[:len(parents)-1]
  36.                 } else {
  37.                         // 没有明确的父(或者没有更多的父)转到数据库获取
  38.                         header = chain.GetHeader(hash, number)
  39.                         if header == nil {
  40.                                 return nil, consensus.ErrUnknownAncestor
  41.                         }
  42.                 }
  43.                 headers = append(headers, header)
  44.                 number, hash = number-1, header.ParentHash
  45.         }
  46.         // 找到了之前的快照,将所有的pedding块头放在它上面
  47.         for i := 0; i  0 {
  48.                 if err = snap.store(c.db); err != nil {
  49.                         return nil, err
  50.                 }
  51.                 log.Trace("Stored voting snapshot to disk", "number", snap.Number, "hash", snap.Hash)
  52.         }
  53.         return snap, err
  54. }
Copy the Code

在snapshot中,snap.apply通过区块头来创建一个新的快照,这个apply中主要做什么操作?
  1. //apply将给定的区块头应用于原始头来创建新的授权快照。
  2. func (s *Snapshot) apply(headers []*types.Header) (*Snapshot, error) {
  3.           //可以传空区块头
  4.     if len(headers) == 0 {
  5.         return s, nil
  6.     }
  7.           //完整性检查区块头可用性
  8.     for i := 0; i = limit {
  9.             delete(snap.Recents, number-limit)
  10.         }
  11.         // 从区块头中解密出来签名者地址
  12.         signer, err := ecrecover(header, s.sigcache)
  13.         if err != nil {
  14.             return nil, err
  15.         }
  16.         if _, ok := snap.Signers[signer]; !ok {
  17.             return nil, errUnauthorized
  18.         }
  19.         for _, recent := range snap.Recents {
  20.             if recent == signer {
  21.                 return nil, errUnauthorized
  22.             }
  23.         }
  24.         snap.Recents[number] = signer
  25.         // 区块头认证,不管该签名者之前的任何投票
  26.         for i, vote := range snap.Votes {
  27.             if vote.Signer == signer && vote.Address == header.Coinbase {
  28.                 // 从缓存计数器中移除该投票
  29.                 snap.uncast(vote.Address, vote.Authorize)
  30.                 // 从按时间排序的列表中移除投票
  31.                 snap.Votes = append(snap.Votes[:i], snap.Votes[i+1:]...)
  32.                 break // 只允许一票
  33.             }
  34.         }
  35.         // 从签名者中计数新的投票
  36.         var authorize bool
  37.         switch {
  38.         case bytes.Equal(header.Nonce[:], nonceAuthVote):
  39.             authorize = true
  40.         case bytes.Equal(header.Nonce[:], nonceDropVote):
  41.             authorize = false
  42.         default:
  43.             return nil, errInvalidVote
  44.         }
  45.         if snap.cast(header.Coinbase, authorize) {
  46.             snap.Votes = append(snap.Votes, &Vote{
  47.                 Signer:    signer,
  48.                 Block:     number,
  49.                 Address:   header.Coinbase,
  50.                 Authorize: authorize,
  51.             })
  52.         }
  53.         // 判断票数是否超过一半的投票者,如果投票通过,更新签名者列表
  54.         if tally := snap.Tally[header.Coinbase]; tally.Votes > len(snap.Signers)/2 {
  55.             if tally.Authorize {
  56.                 snap.Signers[header.Coinbase] = struct{}{}
  57.             } else {
  58.                 delete(snap.Signers, header.Coinbase)
  59.                                   // 签名者列表缩减,删除最近剩余的缓存
  60.                 if limit := uint64(len(snap.Signers)/2 + 1); number >= limit {
  61.                     delete(snap.Recents, number-limit)
  62.                 }
  63.                 for i := 0; i
Copy the Code

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)解决方案有效时,返回到矿工并且通知接受结果。
  1. // 检查包头中包含的签名是否满足共识协议要求。该方法接受一个可选的父头的列表,这些父头还不是本地区块链的一部分,用于生成快照
  2. func (c *Clique) verifySeal(chain consensus.ChainReader, header *types.Header, parents []*types.Header) error {
  3.         // 不支持校检创世块
  4.         number := header.Number.Uint64()
  5.         if number == 0 {
  6.                 return errUnknownBlock
  7.         }
  8.         // 检索出所需的区块对象来校检去开头和将其缓存
  9.         snap, err := c.snapshot(chain, number-1, header.ParentHash, parents)
  10.         if err != nil {
  11.                 return err
  12.         }
  13.         //解析授权密钥并检查签署者,ecrecover方法从区块头中反解出Extra字段中签名字符串来获取签名者地址
  14.         signer, err := ecrecover(header, c.signatures)
  15.         if err != nil {
  16.                 return err
  17.         }
  18.         if _, ok := snap.Signers[signer]; !ok {
  19.                 return errUnauthorized
  20.         }
  21.         for seen, recent := range snap.Recents {
  22.                 if recent == signer {
  23.                         // 签署者是最近的,只有当前块没有移出时才会失败,参见seal中的机会均等
  24.                         if limit := uint64(len(snap.Signers)/2 + 1); seen > number-limit {
  25.                                 return errUnauthorized
  26.                         }
  27.                 }
  28.         }
  29.         // 设置区块难度,参见上面的区块难度部分
  30.         inturn := snap.inturn(header.Number.Uint64(), signer)
  31.         if inturn && header.Difficulty.Cmp(diffInTurn) != 0 {
  32.                 return errInvalidDifficulty
  33.         }
  34.         if !inturn && header.Difficulty.Cmp(diffNoTurn) != 0 {
  35.                 return errInvalidDifficulty
  36.         }
  37.         return nil
  38. }
Copy the Code

前面已经分析了Clique的认证节点的出块和校检的过程,那么如何来区分一个节点是认证节点还是一个普通节点?以及一个授权者列表是如何产生并如何全网同步的?
Clique通过投票机制来确认一个认证节点,投票的范围在委员会中,委员会就是所有节点矿工集合,普通节点没有区块生成权利。矿工的投票流程如下:
委员会节点通过RPC调用Propose,对某节点状态变更,从普通节点变成认证阶段,或者相反,写入到Clique.purposal集合中
  1. // Propose注入一个新的授权提案,可以授权一个签名者或者移除一个。
  2. func (api *API) Propose(address common.Address, auth bool) {
  3.     api.clique.lock.Lock()
  4.     defer api.clique.lock.Unlock()
  5.     api.clique.proposals[address] = auth// true:授权,false:移除
  6. }
Copy the Code

本地认证节点在一次区块打包的过程中,从purposal池中随机挑选一条还未被应用的purposal,并将信息填入区块头,将区块广播给其他节点;
  1. //Clique.Prepare
  2.                 // 抓取所有有意义投票的提案
  3.                 addresses := make([]common.Address, 0, len(c.proposals))
  4.                 for address, authorize := range c.proposals {
  5.                         if snap.validVote(address, authorize) {
  6.                                 addresses = append(addresses, address)
  7.                         }
  8.                 }
  9.                 // If there's pending proposals, cast a vote on them
  10.                 if len(addresses) > 0 {
  11.                         header.Coinbase = addresses[rand.Intn(len(addresses))] //随机挑选一条投票节点的地址赋值给区块头的Coinbase字段。
  12.                         // 通过提案内容来组装区块头的随机数字段。
  13.                         if c.proposals[header.Coinbase] {
  14.                                 copy(header.Nonce[:], nonceAuthVote)
  15.                         } else {
  16.                                 copy(header.Nonce[:], nonceDropVote)
  17.                         }
  18.                 }
Copy the Code

在挖矿开始以后,会在miner.start()中提交一个commitNewWork,其中调用上面Prepare
  1.         if err := self.engine.Prepare(self.chain, header); err != nil {
  2.                 log.Error("Failed to prepare header for mining", "err", err)
  3.                 return
  4.         }
Copy the Code

其他节点在接收到区块后,取出其中的信息,封装成一个vote进行存储,并将投票结果应用到本地,若关于目标节点的状态更改获得的一致投票超过1/2,则更改目标节点的状态:若为新增认证节点,将目标节点的地址添加到本地的认证节点的列表中;若为删除认证节点,将目标节点的地址从本地的认证节点列表中删除。具体实现可以查看上面的Snapshot.apply()方法



以太坊中除了基于运算能力的POW(Ethash)外,还有基于权利证明的POA共识机制,Clique是以太坊的POA共识算法的实现,这里主要对POA的Clique相关源码做一个解读分析。
You have to log in before you can reply Login | 立即注册

Points Rules

Write the first review

卫蒙更夜沙 小学生
  • Follow

    0

  • Following

    0

  • Articles

    3

Promoted