PoW共识机制又双来了

之前已经讲了两篇关于PoW的内容，基本上把PoW介绍的很详细了（个人水平有限），那么我们是否可以通过bitcoin中的源码再对PoW有一个更深入的了解呢？当时是可以的，接下来，咱们就从Bitcoin的源码入手，再来详细的分析一波：

CheckProofOfWork函数

首先我们来说对于PoW最为核心的代码部分，很短，但是很重要：

bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
{
    bool fNegative;
    bool fOverflow;
    arith_uint256 bnTarget;
    // nBits就是当前的一个难度值，通过使用SetCompact函数将nBits转换为长度为256的类似于hash值的一个值
    bnTarget.SetCompact(nBits, &fNegative, &fOverflow);

    // 对这些内容进行检查，1）hash值为负数，2）bnTarget通过SetCompact获得的值为0，3）溢出，4）目标难度值比最低难度值还要低
    if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(params.powLimit))
        return false;

    // Check proof of work matches claimed amount
    // 如果所得hash值经过转换后比当前难度值的hash值要大，则返回失败
    if (UintToArith256(hash) > bnTarget)
        return false;

    return true;
}

整个代码当中有一部分内容需要着重注意：

bnTarget > UintToArith256(params.powLimit)

这一句的代码显示的内容应该是bnTarget大于powLimit（最低难度）的256转换值，但是我在注释里面写的命名是要小于最低难度啊，这是为什么呢？

在这里是一个我们需要注意的内容:
我们虽然总是说判断的是难度值的大小，但是根据bitcoin中的源码的分析来说，他的bitcoin的大小是和数值正好相反的，也就是说，数值越大，难度越小！

这样就可以很好的解决前面的问题了。

但是我们也不要和后面的那一句混了：

UintToArith256(hash) > bnTarget

这一句判断的是最终类hash值与目标难度hash值的比较，这个比较还是按照我们正常的规定来理解就好，一旦找到比target小的值，就可以直接返回true，也就是找到了我们想要的那个nonce值。

GetNextWorkRequired函数

这个函数的主要功能是用来进行判断的，判断的是什么呢？我们在上一篇文章中说到过我们要在一定时间后对难度进行调整，这里判断的就是判断是否需要对难度进行调整。

unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
{
    assert(pindexLast != nullptr);
    unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();
    // 每个难度周期仅进行一次周期的调整
    // 检查是否到达难度调整时间，一个周期是指每两周进行一次调整，10分钟一块，2016块，总共20160分钟

    // Only change once per difficulty adjustment interval
    if ((pindexLast->nHeight+1) % params.DifficultyAdjustmentInterval() != 0)
    {
        if (params.fPowAllowMinDifficultyBlocks)
        {
            // Special difficulty rule for testnet:
            // If the new block's timestamp is more than 2* 10 minutes
            // then allow mining of a min-difficulty block.
            if (pblock->GetBlockTime() > pindexLast->GetBlockTime() + params.nPowTargetSpacing*2)
                return nProofOfWorkLimit;
            else
            {
                // Return the last non-special-min-difficulty-rules-block
                const CBlockIndex* pindex = pindexLast;
                while (pindex->pprev && pindex->nHeight % params.DifficultyAdjustmentInterval() != 0 && pindex->nBits == nProofOfWorkLimit)
                    pindex = pindex->pprev;
                return pindex->nBits;
            }
        }
        return pindexLast->nBits;
    }

    // Go back by what we want to be 14 days worth of blocks
    // 如果已经到了调整的时间，向上回溯找到这一组2016个区块的首地址
    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
    assert(nHeightFirst >= 0);
    const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
    assert(pindexFirst);
    // 重新计算难度值
    return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
}

这是Bitcoin中对于是否要调整难度进行的判断，那么我们还看到三行很明显的注释：

// Special difficulty rule for testnet:
// If the new block's timestamp is more than 2* 10 minutes
// then allow mining of a min-difficulty block.

我们发现，里面还有一段是对test，也就是测试网络进行难度调节的内容，我们可以根据他的注释看出他的难度调整和我们主网上是不一样的，但是我们也不太需要在意。

我们看函数整体，只要我们的判断他已经到了需要调整的时间，我们要做的就是两步：
1) 向上追溯2016个块，并计算相应的生成时间；
2) 重新计算难度值
第一步的代码很简单，所以不用赘述。

我们主要再来看一下关于重新计算难度的函数。

CalculateNextWorkRequired函数

unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
{
    if (params.fPowNoRetargeting)
        return pindexLast->nBits;

    // Limit adjustment step
    // 难度调整步骤
    // 如果生成时间小于1/4，就按照1/4来计算，大于4倍，就按照4倍来计算，以防止出现难度偏差过大的现象。
    int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
    if (nActualTimespan < params.nPowTargetTimespan/4)
        nActualTimespan = params.nPowTargetTimespan/4;
    if (nActualTimespan > params.nPowTargetTimespan*4)
        nActualTimespan = params.nPowTargetTimespan*4;

    // Retarget
    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
    arith_uint256 bnNew;
    bnNew.SetCompact(pindexLast->nBits);   // 首先将上一个区块的难度置到bnNew当中
    // 新难度 = 旧难度 * 实际生成时间 / 预定生成时间
    bnNew *= nActualTimespan;
    bnNew /= params.nPowTargetTimespan;

    // 难度也是有最低值的，起码不能比最低难度还容易
    if (bnNew > bnPowLimit)
        bnNew = bnPowLimit;

    return bnNew.GetCompact();
}

这就是关于计算难度的函数，内容也是很好理解的，我们选择几点比较重要的来说：

1.nActualTimespan的计算

int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
    if (nActualTimespan < params.nPowTargetTimespan/4)
        nActualTimespan = params.nPowTargetTimespan/4;
    if (nActualTimespan > params.nPowTargetTimespan*4)
        nActualTimespan = params.nPowTargetTimespan*4;

这一部分的代码就是用来计算实际使用时间的代码，首先肯定是左后一块的时间减去第一块的时间，但接下来还有两个if判断语句，意思也很好理解，如果实际花费时间小于理论时间的1/4，就按照1/4来处理；如果实际花费时间大于理论时间的4倍，就按照4倍来处理。这个理由也很简单，如果相差的时间太大的话，那么理论上调整的难度的大小的范围就会很大，因此我们需要将其控制在一定的范围，那么在bitcoin中规定，最小不低于1/4，最大不超过4倍。

2.bnNew的计算

我们发现bnNew也就是我们想要求的那个新的难度值，求解公式也很简单：

 arith_uint256 bnNew;
 bnNew.SetCompact(pindexLast->nBits);  
 bnNew *= nActualTimespan;
 bnNew /= params.nPowTargetTimespan;

我们定义bnNew之后，就使用我们的公式：

新难度 = 旧难度 * 实际生成时间 / 预定生成时间

就可以计算出来新的难度值，那么我们计算后，还是刚才那个问题，一定不能忽视，就是难度越大，数值越小！因为我们如果nActualTimespan计算出来比20160(2016 * 10)分钟小的时候，最后得到的 bnNew是比之前要小的，但是我们想要的是比他大的值，因此我们一定要好好理解这个内容。

总结

以上就是对于bitcoin源码中关于pow的几个函数的解读，其实总体看来，还是很简单的，因为我们只需要理解3个函数的功能即可，里面的一些参数，我们可以按照他的定义一一理解即可，因此，我们对于bitcoin的理解又加深了一步，加油！

区块链真的是一个很有意思的东西，欢迎大家一起来交流学习~