13. Single及PoW共识

13.1. 介绍

Single以及PoW属于不同类型的区块链共识算法。其中，PoW(Proof Of Work，工作量证明)是通过解决一道特定的问题从而达成共识的区块链共识算法；而Single亦称为授权共识，在一个区块链网络中授权固定的address来记账本。Single一般在测试环境中使用，不适合大规模的应用环境。PoW适用于公有链应用场景。

13.2. 算法流程

Single共识

  • 对于矿工：Single是固定 address 周期性出块，因此在调用 CompeteMaster 的时候主要判断当前时间与上一次出块时间间隔是否达到一个周期；
  • 对于验证节点：验证节点除了密码学方面必要的验证之外，还会验证矿工与本地记录的矿工是否一致；

Pow共识

  • 对于矿工：每次调用 CompeteMaster 都返回 true，表明每次调用 CompeteMaster 的结果都是矿工该出块了；
  • 对于验证节点：验证节点除了密码学方面必要的验证之外，还会验证区块的难度值是否符合要求；

13.3. 在超级链中使用Single或PoW共识

只需修改 data/config 中的创世块配置即可指定使用共识

13.3.1. 使用Single共识的创世块配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
{
    "version" : "1",
    "consensus" : {
        # 共识算法类型
        "type"  : "single",
        # 指定出块的address
        "miner" : "dpzuVdosQrF2kmzumhVeFQZa1aYcdgFpN"
    },
    # 预分配
    "predistribution":[
        {
            "address" : "dpzuVdosQrF2kmzumhVeFQZa1aYcdgFpN",
            "quota" : "100000000000000000000"
        }
    ],
    # 区块大小限制
    "maxblocksize" : "128",
    # 出块周期
    "period" : "3000",
    # 出块奖励
    "award" : "428100000000",
    # 精度
    "decimals" : "8",
    # 出块奖励衰减系数
    "award_decay": {
        "height_gap": 31536000,
        "ratio": 1
    },
    # 系统权限相关配置
    "permission": {
        "CreateAccount" : { "rule" : "NULL", "acl": {}},
        "SetAccountAcl": { "rule" : "NULL", "acl": {}},
        "SetContractMethodAcl": { "rule" : "NULL", "acl": {}}
    }
}

13.3.2. 使用PoW共识的创世块配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
{
    "version" : "1",
    # 预分配
    "predistribution":[
        {
            "address" : "Y4TmpfV4pvhYT5W17J7TqHSLo6cqq23x3",
            "quota" : "1000000000000000"
        }
    ],
    "maxblocksize" : "128",
    "award" : "1000000",
    "decimals" : "8",
    "award_decay": {
        "height_gap": 31536000,
        "ratio": 0.5
    },
    "genesis_consensus":{
        "name": "pow",
        "config": {
                # 默认难度值
                "defaultTarget": "19",
                # 每隔10个区块做一次难度调整
                "adjustHeightGap": "10",
                "expectedPeriod": "15",
                "maxTarget": "22"
        }
    }
}

13.4. 关键技术

Single共识的原理简单，不再赘述。

PoW共识

解决一道难题过程，执行流程如下：

  • step1 每隔一个周期判断是否接收到新的区块。若是，跳出解决难题流程，若不是，进行 step2 ；
  • step2 判断当前计算难度值是否符合要求。若是，跳出难题解决流程，若不是难度值加1，继续 step1 ；

伪代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// 在每次挖矿时，设置为true
// StartPowMinning
for {
    // 每隔round次数，判断是否接收到新的区块，避免与网络其他节点不同步
    if gussCount % round == 0 && !l.IsEnablePowMinning() {
        break
    }
    // 判断当前计算难度值是否符合要求
    if valid = IsProofed(block.Blockid, targetBits); !valid {
        guessNonce += 1
        block.Nonce = guessNonce
        block.Blockid, err = MakeBlockID(block)
        if err != nil {
            return nil, err
        }
        guessCount++
        continue
    }
    break
}
// valid为false说明还没挖到块
// l.IsEnablePowMinning() == true  --> 自己挖出块
// l.IsEnablePowMinning() == false --> 被中断
if !valid && !l.IsEnablePowMinning() {
    l.xlog.Debug("I have been interrupted from a remote node, because it has a higher block")
    return nil, ErrMinerInterrupt
}

计算当前区块难度值过程，执行流程如下：

  • step1 判断当前区块所在高度是否比较小。若是，直接复用默认的难度值，跳出计算区块难度值过程，若不是，继续 step2 ；
  • step2 获取当前区块的前一个区块的难度值；
  • step3 判断当前区块是否在下一个难度调整周期范围内。若是，继续 step4 ；若不是，继续 step5 ；
  • step4 获取当前区块的前一个区块的难度值，并计算经历N个区块，预期/实际消耗的时间，并根据公式调整难度值，跳出计算区块难度值过程；
  • step5 如果当前区块所在高度在下一次区块难度调整的周期范围内，直接复用前一个区块的难度值，跳出计算区块难度值过程；

伪代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
func (pc *PowConsensus) calDifficulty(curBlock *pb.InternalBlock) int32 {
    // 如果当前区块所在高度比较小，直接复用默认的难度值
    if curBlock.Height <= int64(pc.config.adjustHeightGap) {
        return pc.config.defaultTarget
    }
    height := curBlock.Height
    preBlock, err := pc.getPrevBlock(curBlock, 1)
    if err != nil {
        pc.log.Warn("query prev block failed", "err", err, "height", height-1)
        return pc.config.defaultTarget
    }
    // 获取当前区块前一个区块的难度值
    prevTargetBits := pc.getTargetBitsFromBlock(preBlock)
    // 如果当前区块所在高度恰好是难度值调整所在的高度周期
    if height%int64(pc.config.adjustHeightGap) == 0 {
        farBlock, err := pc.getPrevBlock(curBlock, pc.config.adjustHeightGap)
        if err != nil {
            pc.log.Warn("query far block failed", "err", err, "height", height-int64(pc.config.adjustHeightGap))
            return pc.config.defaultTarget
        }
        // 经历N个区块，预期消耗的时间
        expectedTimeSpan := pc.config.expectedPeriod * (pc.config.adjustHeightGap - 1)
        // 经历N个区块，实际消耗的时间
        actualTimeSpan := int32((preBlock.Timestamp - farBlock.Timestamp) / 1e9)
        pc.log.Info("timespan diff", "expectedTimeSpan", expectedTimeSpan, "actualTimeSpan", actualTimeSpan)
        //at most adjust two bits, left or right direction
        // 避免难度值调整太快，防止恶意攻击
        if actualTimeSpan < expectedTimeSpan/4 {
            actualTimeSpan = expectedTimeSpan / 4
        }
        if actualTimeSpan > expectedTimeSpan*4 {
            actualTimeSpan = expectedTimeSpan * 4
        }
        difficulty := big.NewInt(1)
        difficulty.Lsh(difficulty, uint(prevTargetBits))
        difficulty.Mul(difficulty, big.NewInt(int64(expectedTimeSpan)))
        difficulty.Div(difficulty, big.NewInt(int64(actualTimeSpan)))
        newTargetBits := int32(difficulty.BitLen() - 1)
        if newTargetBits > pc.config.maxTarget {
            pc.log.Info("retarget", "newTargetBits", newTargetBits)
            newTargetBits = pc.config.maxTarget
        }
        pc.log.Info("adjust targetBits", "height", height, "targetBits", newTargetBits, "prevTargetBits", prevTargetBits)
        return newTargetBits
    } else {
        // 如果当前区块所在高度在下一次区块难度调整的周期范围内，直接复用前一个区块的难度值
        pc.log.Info("prev targetBits", "prevTargetBits", prevTargetBits)
        return prevTargetBits
    }
}