> 作者：chirpyli
>
> 來源：[恆生LIGHT雲社群](https://developer.hs.net/thread/1742)

### 挖礦流程概述

比特幣挖礦，其實就是比特幣節點，對交易進行打包出塊，獲取記賬權的同時得到比特幣激勵。挖礦主要流程如下：

1. 收集網路上廣播的交易，進行驗證，加入到交易池中；
2. 構造新塊——將交易池中的交易打包，選擇一條最長的區塊鏈，計算最新塊頭雜湊值作為新塊（候選塊，還未獲得記賬權）前一區塊雜湊；
3. 工作量證明，計算難題，競爭記賬權，如果獲得記賬權，則將新塊廣播出去，如果收到其他節點廣播的新塊，則驗證該新塊，如果新塊通過驗證，則重新開始挖礦流程。

隨著專用礦機的出現，CPU挖礦基本已經被廢棄了，這裡的CPU挖礦程式碼只是用來學習以及測試用，實際礦工並不會使用下面的程式碼來挖礦。開啟CPU挖礦的話，可通過一個 `generatetoaddress`RPC呼叫開啟挖礦到一個特定的地址。

一個比特幣節點可以選擇挖礦也可以選擇不挖礦，如果想挖礦的話，輸入開始挖礦的命令 `bitcoin-cli generatetoaddress`開啟挖礦流程。
下面我們來分析相關原始碼：

```c++
// 開啟挖礦流程後，進入這裡，需要一個交易輸出，及Coinbase交易要將挖礦獎勵給礦工，需要鎖定指令碼
static UniValue generatetoaddress(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 2 || request.params.size() > 3)
        throw std::runtime_error(
            RPCHelpMan{"generatetoaddress",
                "\nMine blocks immediately to a specified address (before the RPC call returns)\n",
                {
                    {"nblocks", RPCArg::Type::NUM, RPCArg::Optional::NO, "How many blocks are generated immediately."},   //設定準備挖多少個區塊
                    {"address", RPCArg::Type::STR, RPCArg::Optional::NO, "The address to send the newly generated bitcoin to."},     //挖礦獎勵輸出地址
                    {"maxtries", RPCArg::Type::NUM, /* default */ "1000000", "How many iterations to try."},
                },
                RPCResult{
            "[ blockhashes ]     (array) hashes of blocks generated\n"
                },
                RPCExamples{
            "\nGenerate 11 blocks to myaddress\n"
            + HelpExampleCli("generatetoaddress", "11 \"myaddress\"")
            + "If you are running the bitcoin core wallet, you can get a new address to send the newly generated bitcoin to with:\n"
            + HelpExampleCli("getnewaddress", "")
                },
            }.ToString());

int nGenerate = request.params[0].get_int();
    uint64_t nMaxTries = 1000000;
    if (!request.params[2].isNull()) {
        nMaxTries = request.params[2].get_int();
    }

CTxDestination destination = DecodeDestination(request.params[1].get_str());
    if (!IsValidDestination(destination)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Error: Invalid address");
    }

CScript coinbase_script = GetScriptForDestination(destination); //用於給礦工獎勵的鎖定指令碼

return generateBlocks(coinbase_script, nGenerate, nMaxTries);   //產生新塊，競爭記賬權
}

static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, uint64_t nMaxTries)
{
    static const int nInnerLoopCount = 0x10000;
    int nHeightEnd = 0;
    int nHeight = 0;

{   // Don't keep cs_main locked
        LOCK(cs_main);
        nHeight = ::ChainActive().Height();
        nHeightEnd = nHeight+nGenerate;
    }
    unsigned int nExtraNonce = 0;
    UniValue blockHashes(UniValue::VARR);
    while (nHeight < nHeightEnd && !ShutdownRequested())    //如果不到指定區塊高度或者沒有停止挖礦請求就一直挖礦
    {
        std::unique_ptr<cblocktemplate> pblocktemplate(BlockAssembler(Params()).CreateNewBlock(coinbase_script));   //構造新塊
        if (!pblocktemplate.get())
            throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
        CBlock *pblock = &pblocktemplate->block;
        {
            LOCK(cs_main);
            IncrementExtraNonce(pblock, ::ChainActive().Tip(), nExtraNonce);        //默克爾根雜湊是在這裡面計算並賦值的。
        }
        //不斷改變nNonce值，計算難題
        while (nMaxTries > 0 && pblock->nNonce < nInnerLoopCount && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
            ++pblock->nNonce;
            --nMaxTries;
        }
        if (nMaxTries == 0) {
            break;
        }
        if (pblock->nNonce == nInnerLoopCount) {
            continue;
        }
        std::shared_ptr<const cblock=""> shared_pblock = std::make_shared<const cblock="">(*pblock);
        if (!ProcessNewBlock(Params(), shared_pblock, true, nullptr))
            throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
        ++nHeight;
        blockHashes.push_back(pblock->GetHash().GetHex());
    }
    return blockHashes;
}
```

後面我們展開這裡面的程式碼，詳細分析一下這裡面的具體流程。先從收集交易開始。

### 驗證交易加入到交易池

比特幣錢包構造交易併發布到比特幣區塊鏈網路中，其他節點收到網路上接收到的交易，先進行驗證，驗證交易後，比特幣節點會將這些交易新增到自己的記憶體池中同時將交易廣播給其他節點。記憶體池也稱作交易池，用來暫存尚未被確認（加入到區塊）的交易記錄。這裡的驗證規則如下（好長，且有可能會發生變化）：

- 交易的語法和資料結構必須正確。
- 交易輸入和輸出均不能為空。
- 交易位元組數的大小必須小於MAX_BLOCK_SIZE。
- 每個交易輸出的彙總價值必須在允許範圍內（小於2100萬比特幣，大於0）。
- 交易輸入的雜湊值不能為零，不應該轉播Coinbase交易。
- nLockTime小於或等於INT_MAX。
- 交易位元組數必須大於或等於100。
- 交易中籤名操作的數量必須小於簽名操作的限制值。
- 解鎖指令碼（scriptSig）只能將數字壓入堆疊，鎖定指令碼（scriptPubKey）必須匹配isStandard格式（這將拒絕“非標準”交易）。
- 交易池或者主分支的區塊中必須存在匹配的交易。
- 對於每個輸入，如果引用的輸出在交易池的其他交易中存在，交易必須被拒絕。
- 對於每個輸入，需要在主分支和交易池中查詢被引用的輸出交易。如果任何輸入對應的輸出交易不存在，那麼這就是個孤兒交易。如果其對應的交易不在孤兒交易池中，將其加入孤兒交易池。
- 對於每個輸入，如果引用的輸出交易是一個鑄幣交易的輸出，必須至少經過COINBASE_MATURITY（100）確認。
- 使用輸出交易計算輸入價值，檢查每個輸入價值以及彙總值，看其是否超過允許範圍（小於2100萬比特幣，大於0）。
- 如果輸入價值彙總小於輸出價值，拒絕這筆交易。
- 如果交易費用太小以致無法加入一個空的區塊，拒絕這筆交易。
- 每個輸入的解鎖指令碼必須基於相應的輸出鎖定指令碼進行驗證。

### 構造新塊

前面收集網路上的交易並驗證，加入交易池，這一過程其實是挖礦流程的預備工作，構造新塊並進行難題計算才是挖礦流程的核心步驟。

#### 構造過程

構造新塊，其實你看一下區塊結構，把相關欄位設定好就可以了。

```c++
class CBlock : public CBlockHeader
{
public:
    // network and disk
    std::vector<ctransactionref> vtx;

//...省略部分程式碼...
}
```

從交易池中按交易優先順序選取部分交易加入到區塊交易列表中，並開始構造區塊頭，最主要的是前一區塊雜湊和默克爾樹根雜湊值。這裡還需要構造一筆Coinbase交易，並作為整個區塊的第一筆交易。

```c++
class CBlockHeader
{
public:
    // header
    int32_t nVersion;       // 版本號，指定驗證規則(indicates which set of block validation rules to follow) 
    uint256 hashPrevBlock;  // 前一區塊雜湊（實際計算時取得是前一區塊頭雜湊）(a reference to the parent/previous block in the blockchain)
    uint256 hashMerkleRoot; // 默克爾根雜湊(a hash (root hash) of the merkle tree data structure containing a block's transactions)
    uint32_t nTime;         // 時戳(seconds from Unix Epoch)
    uint32_t nBits;         // 區塊難度(aka the difficulty target for this block)
    uint32_t nNonce;        // 工作量證明nonce(value used in proof-of-work)

// ...部分程式碼省略...
}
```

前一區塊雜湊值是選取當前區塊鏈最長的一條鏈條的最高區塊頭部做雜湊，計算出前一區塊雜湊。默克爾根雜湊值根據交易列表計算得出。下面我們看一下構造新塊的原始碼：

```c++
// 這個類負責構造新塊（準確的說應該是候選塊，因為還沒有經過工作量證明）
/** Generate a new block, without valid proof-of-work */
class BlockAssembler
{
private:
    // The constructed block template
    std::unique_ptr<cblocktemplate> pblocktemplaclass CBlock : public CBlockHeader
{
public:
    // network and disk
    std::vector<ctransactionref> vtx;te;
    // A convenience pointer that always refers to the CBlock in pblocktemplate
    CBlock* pblock;

// Configuration parameters for the block size
    bool fIncludeWitness;
    unsigned int nBlockMaxWeight;
    CFeeRate blockMinFeeRate;

// Information on the current status of the block
    uint64_t nBlockWeight;
    uint64_t nBlockTx;
    uint64_t nBlockSigOpsCost;
    CAmount nFees;
    CTxMemPool::setEntries inBlock;

// Chain context for the block
    int nHeight;
    int64_t nLockTimeCutoff;
    const CChainParams& chainparams;

public:
    struct Options {
        Options();
        size_t nBlockMaxWeight;
        CFeeRate blockMinFeeRate;
    };

explicit BlockAssembler(const CChainParams& params);
    BlockAssembler(const CChainParams& params, const Options& options);

/** Construct a new block template with coinbase to scriptPubKeyIn */
    std::unique_ptr<cblocktemplate> CreateNewBlock(const CScript& scriptPubKeyIn);    //最重要的是這個成員函式，建立新塊

static Optional<int64_t> m_last_block_num_txs;
    static Optional<int64_t> m_last_block_weight;

private:
    // utility functions
    /** Clear the block's state and prepare for assembling a new block */
    void resetBlock();
    /** Add a tx to the block */
    void AddToBlock(CTxMemPool::txiter iter);

// Methods for how to add transactions to a block.
    /** Add transactions based on feerate including unconfirmed ancestors
      * Increments nPackagesSelected / nDescendantsUpdated with corresponding
      * statistics from the package selection (for logging statistics). */
    void addPackageTxs(int &nPackagesSelected, int &nDescendantsUpdated) EXCLUSIVE_LOCKS_REQUIRED(mempool.cs);

// helper functions for addPackageTxs()
    /** Remove confirmed (inBlock) entries from given set */
    void onlyUnconfirmed(CTxMemPool::setEntries& testSet);
    /** Test if a new package would "fit" in the block */
    bool TestPackage(uint64_t packageSize, int64_t packageSigOpsCost) const;
    /** Perform checks on each transaction in a package:
      * locktime, premature-witness, serialized size (if necessary)
      * These checks should always succeed, and they're here
      * only as an extra check in case of suboptimal node configuration */
    bool TestPackageTransactions(const CTxMemPool::setEntries& package);
    /** Return true if given transaction from mapTx has already been evaluated,
      * or if the transaction's cached data in mapTx is incorrect. */
    bool SkipMapTxEntry(CTxMemPool::txiter it, indexed_modified_transaction_set &mapModifiedTx, CTxMemPool::setEntries &failedTx) EXCLUSIVE_LOCKS_REQUIRED(mempool.cs);
    /** Sort the package in an order that is valid to appear in a block */
    void SortForBlock(const CTxMemPool::setEntries& package, std::vector<:txiter>& sortedEntries);
    /** Add descendants of given transactions to mapModifiedTx with ancestor
      * state updated assuming given transactions are inBlock. Returns number
      * of updated descendants. */
    int UpdatePackagesForAdded(const CTxMemPool::setEntries& alreadyAdded, indexed_modified_transaction_set &mapModifiedTx) EXCLUSIVE_LOCKS_REQUIRED(mempool.cs);
};
```

我們接下來看一下 `BlockAssembler`類最重要的成員函式 `CreateNewBlock`的原始碼：

```c++
//引數scriptPubKeyIn表示Coinbase交易輸出鎖定指令碼
std::unique_ptr<cblocktemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn)
{
    int64_t nTimeStart = GetTimeMicros();

resetBlock();

pblocktemplate.reset(new CBlockTemplate());

if(!pblocktemplate.get())
        return nullptr;
    pblock = &pblocktemplate->block; // pointer for convenience

// Add dummy coinbase tx as first transaction
    pblock->vtx.emplace_back();   
    pblocktemplate->vTxFees.push_back(-1); // updated at end
    pblocktemplate->vTxSigOpsCost.push_back(-1); // updated at end

LOCK2(cs_main, mempool.cs);
    CBlockIndex* pindexPrev = ::ChainActive().Tip();    //選擇當前最長鏈，最高區塊
    assert(pindexPrev != nullptr);
    nHeight = pindexPrev->nHeight + 1;

pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus()); //設定版本號欄位
    // -regtest only: allow overriding block.nVersion with
    // -blockversion=N to test forking scenarios
    if (chainparams.MineBlocksOnDemand())
        pblock->nVersion = gArgs.GetArg("-blockversion", pblock->nVersion);

pblock->nTime = GetAdjustedTime();  //設定時戳欄位
    const int64_t nMedianTimePast = pindexPrev->GetMedianTimePast();

nLockTimeCutoff = (STANDARD_LOCKTIME_VERIFY_FLAGS & LOCKTIME_MEDIAN_TIME_PAST)
                       ? nMedianTimePast
                       : pblock->GetBlockTime();

// Decide whether to include witness transactions
    // This is only needed in case the witness softfork activation is reverted
    // (which would require a very deep reorganization).
    // Note that the mempool would accept transactions with witness data before
    // IsWitnessEnabled, but we would only ever mine blocks after IsWitnessEnabled
    // unless there is a massive block reorganization with the witness softfork
    // not activated.
    // TODO: replace this with a call to main to assess validity of a mempool
    // transaction (which in most cases can be a no-op).
    fIncludeWitness = IsWitnessEnabled(pindexPrev, chainparams.GetConsensus());

int nPackagesSelected = 0;
    int nDescendantsUpdated = 0;
    addPackageTxs(nPackagesSelected, nDescendantsUpdated);  //新增交易池中交易到區塊中

int64_t nTime1 = GetTimeMicros();

m_last_block_num_txs = nBlockTx;
    m_last_block_weight = nBlockWeight;

// Create coinbase transaction. 建立Coinbase交易
    CMutableTransaction coinbaseTx;
    coinbaseTx.vin.resize(1);
    coinbaseTx.vin[0].prevout.SetNull();    //Coinbase交易是沒有輸入，只有輸出的
    coinbaseTx.vout.resize(1);
    coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;   //鎖定指令碼
    coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());    //輸出給礦工，交易費+挖礦獎勵
    coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
    pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));     //Coinbase交易放到交易列表的第一位，區塊中的第一筆交易
    pblocktemplate->vchCoinbaseCommitment = GenerateCoinbaseCommitment(*pblock, pindexPrev, chainparams.GetConsensus());
    pblocktemplate->vTxFees[0] = -nFees;

LogPrintf("CreateNewBlock(): block weight: %u txs: %u fees: %ld sigops %d\n", GetBlockWeight(*pblock), nBlockTx, nFees, nBlockSigOpsCost);

// Fill in header   
    pblock->hashPrevBlock  = pindexPrev->GetBlockHash();    //設定區塊頭中前一區塊雜湊欄位
    UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
    pblock->nBits          = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());    //計算難度值，設定難度值欄位，具體計算方法下面挖礦難度一節會講到
    pblock->nNonce         = 0;     //隨機數，初始置為0，等待後面不斷調整
    pblocktemplate->vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock->vtx[0]);

CValidationState state;
    if (!TestBlockValidity(state, chainparams, *pblock, pindexPrev, false, false)) {
        throw std::runtime_error(strprintf("%s: TestBlockValidity failed: %s", __func__, FormatStateMessage(state)));
    }
    int64_t nTime2 = GetTimeMicros();

LogPrint(BCLog::BENCH, "CreateNewBlock() packages: %.2fms (%d packages, %d updated descendants), validity: %.2fms (total %.2fms)\n", 0.001 * (nTime1 - nTimeStart), nPackagesSelected, nDescendantsUpdated, 0.001 * (nTime2 - nTime1), 0.001 * (nTime2 - nTimeStart));

return std::move(pblocktemplate);
}
```

可以看到，除了默克爾根雜湊欄位，其他主要欄位都已經構造完成，而默克爾根雜湊欄位的構造在下面程式碼中會構造。

```c++
void IncrementExtraNonce(CBlock* pblock, const CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
{
    // Update nExtraNonce
    static uint256 hashPrevBlock;
    if (hashPrevBlock != pblock->hashPrevBlock)
    {
        nExtraNonce = 0;
        hashPrevBlock = pblock->hashPrevBlock;
    }
    ++nExtraNonce;
    unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2
    CMutableTransaction txCoinbase(*pblock->vtx[0]);
    txCoinbase.vin[0].scriptSig = (CScript() << nHeight << CScriptNum(nExtraNonce)) + COINBASE_FLAGS;
    assert(txCoinbase.vin[0].scriptSig.size() <= 100);

pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
    pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);  // 計算默克爾根雜湊
}

uint256 BlockMerkleRoot(const CBlock& block, bool* mutated)
{
    // 計算交易雜湊值
    std::vector<uint256> leaves;
    leaves.resize(block.vtx.size());
    for (size_t s = 0; s < block.vtx.size(); s++) {
        leaves[s] = block.vtx[s]->GetHash();
    }
    return ComputeMerkleRoot(std::move(leaves), mutated);
}

uint256 ComputeMerkleRoot(std::vector<uint256> hashes, bool* mutated) {
    bool mutation = false;
    while (hashes.size() > 1) {     // 逐層向上計算，一直計算到根雜湊
        if (mutated) {
            for (size_t pos = 0; pos + 1 < hashes.size(); pos += 2) {
                if (hashes[pos] == hashes[pos + 1]) mutation = true;
            }
        }
        if (hashes.size() & 1) {    // 奇數個數交易，最後一個交易與自己配對
            hashes.push_back(hashes.back());
        }
        SHA256D64(hashes[0].begin(), hashes[0].begin(), hashes.size() / 2);
        hashes.resize(hashes.size() / 2);
    }
    if (mutated) *mutated = mutation;
    if (hashes.size() == 0) return uint256();
    return hashes[0];
}
```

#### 挖礦難度

為了避免隨著算力的波動造成比特幣出塊時間的不穩定，比特幣中挖礦難度值是動態調整的，具體難度值的計算公式如下：
`New Difficulty = Old Difficulty * (Actual Time of Last 2016 Blocks / 20160 minutes)`。每2016個區塊調整一次，這樣比特幣的出塊間隔就被穩定在10分種左右。

難度值計算原始碼如下（很囉嗦，但實際上知道上面那個公式就好了）：

```c++
unsigned int GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlockHeader *pblock, const Consensus::Params& params)
{
    assert(pindexLast != nullptr);
    unsigned int nProofOfWorkLimit = UintToArith256(params.powLimit).GetCompact();

// Only change once per difficulty adjustment interval
    // 塊高是否是2016個區塊的整數倍，如果不是就不用調整難度，就沿用用當前區塊鏈頂點區塊的難度值
    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
    int nHeightFirst = pindexLast->nHeight - (params.DifficultyAdjustmentInterval()-1);
    assert(nHeightFirst >= 0);
    const CBlockIndex* pindexFirst = pindexLast->GetAncestor(nHeightFirst);
    assert(pindexFirst);

return CalculateNextWorkRequired(pindexLast, pindexFirst->GetBlockTime(), params);
}

// 計算下一個難度值
unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
{
    if (params.fPowNoRetargeting)
        return pindexLast->nBits;

// Limit adjustment step
    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 *= nActualTimespan;
    bnNew /= params.nPowTargetTimespan;

if (bnNew > bnPowLimit)
        bnNew = bnPowLimit;

return bnNew.GetCompact();
}
```

#### 挖礦獎勵

礦工競爭記賬權，可獲得交易費及挖礦獎勵，挖礦所得會在Coinbase的交易輸出給礦工。那麼挖礦獎勵是怎麼計算的呢？原始碼如下：

```c++
//根據塊高度計算獎勵值，最開始是獎勵50比特幣，隨後每210000塊遞減一半
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& consensusParams)
{
    int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
    // Force block reward to zero when right shift is undefined.
    if (halvings >= 64)
        return 0;

CAmount nSubsidy = 50 * COIN;
    // Subsidy is cut in half every 210,000 blocks which will occur approximately every 4 years.
    nSubsidy >>= halvings;
    return nSubsidy;
}
```

這個可以在比特幣區塊鏈瀏覽器查到的，第210000個區塊之前，Coinbase挖礦獎勵值（不計算交易費）都是50比特幣，而第210000個區塊獎勵值為25比特幣，之後依次類推。

接下來就要進行難題計算，競爭記賬權了。

### 工作量證明

工作量證明的過程如下，就是不斷改變 `nNonce`值，直到成功或者收到其他節點產生的新塊從而開始下一個新區塊工作量證明的過程。

```c++
static UniValue generateBlocks(const CScript& coinbase_script, int nGenerate, uint64_t nMaxTries)
{
    static const int nInnerLoopCount = 0x10000;
    int nHeightEnd = 0;
    int nHeight = 0;

{   // Don't keep cs_main locked
        LOCK(cs_main);
        nHeight = ::ChainActive().Height();
        nHeightEnd = nHeight+nGenerate;
    }
    unsigned int nExtraNonce = 0;
    UniValue blockHashes(UniValue::VARR);
    while (nHeight < nHeightEnd && !ShutdownRequested())    //如果不到指定區塊高度或者沒有停止挖礦請求就一直挖礦
    {
        std::unique_ptr<cblocktemplate> pblocktemplate(BlockAssembler(Params()).CreateNewBlock(coinbase_script));   //構造新塊
        if (!pblocktemplate.get())
            throw JSONRPCError(RPC_INTERNAL_ERROR, "Couldn't create new block");
        CBlock *pblock = &pblocktemplate->block;
        {
            LOCK(cs_main);
            IncrementExtraNonce(pblock, ::ChainActive().Tip(), nExtraNonce);        //默克爾根雜湊是在這裡面計算並賦值的。
        }
        //不斷改變nNonce值，計算難題
        while (nMaxTries > 0 && pblock->nNonce < nInnerLoopCount && !CheckProofOfWork(pblock->GetHash(), pblock->nBits, Params().GetConsensus())) {
            ++pblock->nNonce;
            --nMaxTries;
        }
        if (nMaxTries == 0) {
            break;
        }
        if (pblock->nNonce == nInnerLoopCount) {
            continue;
        }
        std::shared_ptr<const cblock=""> shared_pblock = std::make_shared<const cblock="">(*pblock);
        if (!ProcessNewBlock(Params(), shared_pblock, true, nullptr))
            throw JSONRPCError(RPC_INTERNAL_ERROR, "ProcessNewBlock, block not accepted");
        ++nHeight;
        blockHashes.push_back(pblock->GetHash().GetHex());
    }
    return blockHashes;
}
```

可以想象，這種CPU挖礦程式碼在GPU或者專用礦機面前已經沒有成功挖礦可能性，而且一些比特幣實現已經將挖礦這部分程式碼移除。這裡分析這段程式碼只是為了對比特幣工作量證明挖礦的過程有個清晰的認識，加深對比特幣工作流程的理解。

> 另外這裡要再擴充套件一下，最開始挖礦，難度值很低，只需要不斷修改隨機數 `nNonce`值就可以了，現在隨著算力的提高，難度越來越大，其實礦工可以修改的不只是 `nNonce`，礦工還可以修改 `nTime`時戳的值，因為只要 `nTime`滿足要求即可，允許一定的誤差（且時間不可能完全同步），還可以修改Coinbase交易中交易輸入中的指令碼來間接修改默克爾根雜湊值 `hashMerkleRoot`，從而達到擴充套件隨機源的目的。所以實際的挖礦程式與上面的CPU挖礦程式不同。且其中最耗時的操作就是雜湊運算的過程，挖礦礦機一般會專門針對雜湊演算法做優化的。

接下來我們繼續分析：

```c++
// 檢查是否滿足難度條件
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params& params)
{
    bool fNegative;
    bool fOverflow;
    arith_uint256 bnTarget;

bnTarget.SetCompact(nBits, &fNegative, &fOverflow);

// Check range
    if (fNegative || bnTarget == 0 || fOverflow || bnTarget > UintToArith256(params.powLimit))
        return false;

// Check proof of work matches claimed amount
    if (UintToArith256(hash) > bnTarget)
        return false;

return true;
}
```

如果滿足上面的難度條件，成功的競爭到了新塊的記賬權，則進入下面的流程：新塊處理流程，主要內容是驗證新塊，驗證通過就存入磁碟並通過網路廣播出去，選擇加入最長鏈。

```c++
// 新塊處理流程
bool ProcessNewBlock(const CChainParams& chainparams, const std::shared_ptr<const cblock=""> pblock, bool fForceProcessing, bool *fNewBlock)
{
    AssertLockNotHeld(cs_main);

{
        CBlockIndex *pindex = nullptr;
        if (fNewBlock) *fNewBlock = false;
        CValidationState state;

// CheckBlock() does not support multi-threaded block validation because CBlock::fChecked can cause data race.
        // Therefore, the following critical section must include the CheckBlock() call as well.
        LOCK(cs_main);

// Ensure that CheckBlock() passes before calling AcceptBlock, as
        // belt-and-suspenders.
        bool ret = CheckBlock(*pblock, state, chainparams.GetConsensus());  //校驗區塊，如果校驗通過就存入磁碟
        if (ret) {
            // Store to disk
            ret = ::ChainstateActive().AcceptBlock(pblock, state, chainparams, &pindex, fForceProcessing, nullptr, fNewBlock);
        }
        if (!ret) {
            GetMainSignals().BlockChecked(*pblock, state);
            return error("%s: AcceptBlock FAILED (%s)", __func__, FormatStateMessage(state));
        }
    }

NotifyHeaderTip();

CValidationState state; // Only used to report errors, not invalidity - ignore it
    if (!::ChainstateActive().ActivateBestChain(state, chainparams, pblock))    //選擇加入最長鏈
        return error("%s: ActivateBestChain failed (%s)", __func__, FormatStateMessage(state));

return true;
}
```

首先要對新區塊進行驗證

```c++
// 驗證新區塊
bool CheckBlock(const CBlock& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW, bool fCheckMerkleRoot)
{
    // These are checks that are independent of context.

if (block.fChecked)
        return true;

// Check that the header is valid (particularly PoW).  This is mostly
    // redundant with the call in AcceptBlockHeader.
    if (!CheckBlockHeader(block, state, consensusParams, fCheckPOW))
        return false;

// Check the merkle root.
    if (fCheckMerkleRoot) {
        bool mutated;
        uint256 hashMerkleRoot2 = BlockMerkleRoot(block, &mutated);     //檢查默克爾根雜湊是否一致
        if (block.hashMerkleRoot != hashMerkleRoot2)
            return state.Invalid(ValidationInvalidReason::BLOCK_MUTATED, false, REJECT_INVALID, "bad-txnmrklroot", "hashMerkleRoot mismatch");

// Check for merkle tree malleability (CVE-2012-2459): repeating sequences
        // of transactions in a block without affecting the merkle root of a block,
        // while still invalidating it.
        if (mutated)
            return state.Invalid(ValidationInvalidReason::BLOCK_MUTATED, false, REJECT_INVALID, "bad-txns-duplicate", "duplicate transaction");
    }

// All potential-corruption validation must be done before we do any
    // transaction validation, as otherwise we may mark the header as invalid
    // because we receive the wrong transactions for it.
    // Note that witness malleability is checked in ContextualCheckBlock, so no
    // checks that use witness data may be performed here.

// Size limits 區塊大小在長度限制之內
    if (block.vtx.empty() || block.vtx.size() * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT || ::GetSerializeSize(block, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT)
        return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-blk-length", "size limits failed");

// First transaction must be coinbase, the rest must not be  第一個交易（且只有第一個）是coinbase交易
    if (block.vtx.empty() || !block.vtx[0]->IsCoinBase())
        return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-missing", "first tx is not coinbase");
    for (unsigned int i = 1; i < block.vtx.size(); i++)
        if (block.vtx[i]->IsCoinBase())
            return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-multiple", "more than one coinbase");

// Check transactions使用檢查清單驗證區塊內的交易並確保它們的有效性
    for (const auto& tx : block.vtx)
        if (!CheckTransaction(*tx, state, true))
            return state.Invalid(state.GetReason(), false, state.GetRejectCode(), state.GetRejectReason(),
                                 strprintf("Transaction check failed (tx hash %s) %s", tx->GetHash().ToString(), state.GetDebugMessage()));

unsigned int nSigOps = 0;
    for (const auto& tx : block.vtx)
    {
        nSigOps += GetLegacySigOpCount(*tx);
    }
    if (nSigOps * WITNESS_SCALE_FACTOR > MAX_BLOCK_SIGOPS_COST)
        return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-blk-sigops", "out-of-bounds SigOpCount");

if (fCheckPOW && fCheckMerkleRoot)
        block.fChecked = true;

return true;
}

// 驗證是否滿足工作量證明
static bool CheckBlockHeader(const CBlockHeader& block, CValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
{
    // Check proof of work matches claimed amount
    if (fCheckPOW && !CheckProofOfWork(block.GetHash(), block.nBits, consensusParams))
        return state.Invalid(ValidationInvalidReason::BLOCK_INVALID_HEADER, false, REJECT_INVALID, "high-hash", "proof of work failed");

return true;
}

// 驗證校驗交易
bool CheckTransaction(const CTransaction& tx, CValidationState &state, bool fCheckDuplicateInputs)
{
    // Basic checks that don't depend on any context
    if (tx.vin.empty())
        return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-vin-empty");
    if (tx.vout.empty())
        return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-vout-empty");
    // Size limits (this doesn't take the witness into account, as that hasn't been checked for malleability)
    if (::GetSerializeSize(tx, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * WITNESS_SCALE_FACTOR > MAX_BLOCK_WEIGHT)
        return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-oversize");

// Check for negative or overflow output values
    CAmount nValueOut = 0;
    for (const auto& txout : tx.vout)
    {
        if (txout.nValue < 0)
            return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-vout-negative");
        if (txout.nValue > MAX_MONEY)
            return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-vout-toolarge");
        nValueOut += txout.nValue;
        if (!MoneyRange(nValueOut))
            return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-txouttotal-toolarge");
    }

// Check for duplicate inputs - note that this check is slow so we skip it in CheckBlock
    if (fCheckDuplicateInputs) {
        std::set<coutpoint> vInOutPoints;
        for (const auto& txin : tx.vin)
        {
            if (!vInOutPoints.insert(txin.prevout).second)
                return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-inputs-duplicate");
        }
    }

if (tx.IsCoinBase())
    {
        if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
            return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-cb-length");
    }
    else
    {
        for (const auto& txin : tx.vin)
            if (txin.prevout.IsNull())
                return state.Invalid(ValidationInvalidReason::CONSENSUS, false, REJECT_INVALID, "bad-txns-prevout-null");
    }

return true;
}
```

上面新塊驗證通過後，將新塊存入磁碟中：

```c++
/** Store block on disk. If dbp is non-nullptr, the file is known to already reside on disk */
bool CChainState::AcceptBlock(const std::shared_ptr<const cblock="">& pblock, CValidationState& state, const CChainParams& chainparams, CBlockIndex** ppindex, bool fRequested, const FlatFilePos* dbp, bool* fNewBlock)
{
    const CBlock& block = *pblock;

if (fNewBlock) *fNewBlock = false;
    AssertLockHeld(cs_main);

CBlockIndex *pindexDummy = nullptr;
    CBlockIndex *&pindex = ppindex ? *ppindex : pindexDummy;

if (!AcceptBlockHeader(block, state, chainparams, &pindex))
        return false;

// Try to process all requested blocks that we don't have, but only
    // process an unrequested block if it's new and has enough work to
    // advance our tip, and isn't too many blocks ahead.
    bool fAlreadyHave = pindex->nStatus & BLOCK_HAVE_DATA;
    bool fHasMoreOrSameWork = (m_chain.Tip() ? pindex->nChainWork >= m_chain.Tip()->nChainWork : true);
    // Blocks that are too out-of-order needlessly limit the effectiveness of
    // pruning, because pruning will not delete block files that contain any
    // blocks which are too close in height to the tip.  Apply this test
    // regardless of whether pruning is enabled; it should generally be safe to
    // not process unrequested blocks.
    bool fTooFarAhead = (pindex->nHeight > int(m_chain.Height() + MIN_BLOCKS_TO_KEEP));

// TODO: Decouple this function from the block download logic by removing fRequested
    // This requires some new chain data structure to efficiently look up if a
    // block is in a chain leading to a candidate for best tip, despite not
    // being such a candidate itself.

// TODO: deal better with return value and error conditions for duplicate
    // and unrequested blocks.
    if (fAlreadyHave) return true;
    if (!fRequested) {  // If we didn't ask for it:
        if (pindex->nTx != 0) return true;    // This is a previously-processed block that was pruned
        if (!fHasMoreOrSameWork) return true; // Don't process less-work chains
        if (fTooFarAhead) return true;        // Block height is too high

// Protect against DoS attacks from low-work chains.
        // If our tip is behind, a peer could try to send us
        // low-work blocks on a fake chain that we would never
        // request; don't process these.
        if (pindex->nChainWork < nMinimumChainWork) return true;
    }

if (!CheckBlock(block, state, chainparams.GetConsensus()) ||
        !ContextualCheckBlock(block, state, chainparams.GetConsensus(), pindex->pprev)) {
        assert(IsBlockReason(state.GetReason()));
        if (state.IsInvalid() && state.GetReason() != ValidationInvalidReason::BLOCK_MUTATED) {
            pindex->nStatus |= BLOCK_FAILED_VALID;
            setDirtyBlockIndex.insert(pindex);
        }
        return error("%s: %s", __func__, FormatStateMessage(state));
    }

// Header is valid/has work, merkle tree and segwit merkle tree are good...RELAY NOW
    // (but if it does not build on our best tip, let the SendMessages loop relay it)
    if (!IsInitialBlockDownload() && m_chain.Tip() == pindex->pprev)
        GetMainSignals().NewPoWValidBlock(pindex, pblock);  // 如果是最新塊，廣播出去

// Write block to history file
    if (fNewBlock) *fNewBlock = true;
    try {
        FlatFilePos blockPos = SaveBlockToDisk(block, pindex->nHeight, chainparams, dbp);
        if (blockPos.IsNull()) {
            state.Error(strprintf("%s: Failed to find position to write new block to disk", __func__));
            return false;
        }
        ReceivedBlockTransactions(block, pindex, blockPos, chainparams.GetConsensus());
    } catch (const std::runtime_error& e) {
        return AbortNode(state, std::string("System error: ") + e.what());
    }

FlushStateToDisk(chainparams, state, FlushStateMode::NONE);

CheckBlockIndex(chainparams.GetConsensus());

return true;
}
```

實際上，廣播的是區塊頭，原始碼如下：

```c++
/**
 * Maintain state about the best-seen block and fast-announce a compact block
 * to compatible peers.
 */
void PeerLogicValidation::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const cblock="">& pblock) {
    std::shared_ptr<const cblockheaderandshorttxids=""> pcmpctblock = std::make_shared<const cblockheaderandshorttxids=""> (*pblock, true);
    const CNetMsgMaker msgMaker(PROTOCOL_VERSION);

LOCK(cs_main);

static int nHighestFastAnnounce = 0;
    if (pindex->nHeight <= nHighestFastAnnounce)
        return;
    nHighestFastAnnounce = pindex->nHeight;

bool fWitnessEnabled = IsWitnessEnabled(pindex->pprev, Params().GetConsensus());
    uint256 hashBlock(pblock->GetHash());

{
        LOCK(cs_most_recent_block);
        most_recent_block_hash = hashBlock;
        most_recent_block = pblock;
        most_recent_compact_block = pcmpctblock;
        fWitnessesPresentInMostRecentCompactBlock = fWitnessEnabled;
    }

// 遍歷連線節點，傳送出去
    connman->ForEachNode([this, &pcmpctblock, pindex, &msgMaker, fWitnessEnabled, &hashBlock](CNode* pnode) {
        AssertLockHeld(cs_main);

// TODO: Avoid the repeated-serialization here
        if (pnode->nVersion < INVALID_CB_NO_BAN_VERSION || pnode->fDisconnect)
            return;
        ProcessBlockAvailability(pnode->GetId());
        CNodeState &state = *State(pnode->GetId());
        // If the peer has, or we announced to them the previous block already,
        // but we don't think they have this one, go ahead and announce it
        if (state.fPreferHeaderAndIDs && (!fWitnessEnabled || state.fWantsCmpctWitness) &&
                !PeerHasHeader(&state, pindex) && PeerHasHeader(&state, pindex->pprev)) {

LogPrint(BCLog::NET, "%s sending header-and-ids %s to peer=%d\n", "PeerLogicValidation::NewPoWValidBlock",
                    hashBlock.ToString(), pnode->GetId());
            connman->PushMessage(pnode, msgMaker.Make(NetMsgType::CMPCTBLOCK, *pcmpctblock));
            state.pindexBestHeaderSent = pindex;
        }
    });
}
```

再下面就是選擇加入最長鏈了，這就涉及到比特幣區塊鏈分叉的問題及相關的處理邏輯，這裡不再細述，感興趣的可以自己閱讀比特幣原始碼。並且，不是所有的區塊鏈都有分叉這個概念的，在許可鏈等採用PBFT共識演算法的區塊鏈中，每個塊一旦形成共識，就是確定性的，而比特幣因Pow共識演算法的原因，新塊產生後並不是確定性的，從而有了分叉這個概念。

至此，比特幣挖礦的流程基本就這些了，可以看到Pow共識演算法在公有鏈中是非常簡單高效的，它相比傳統共識演算法PBFT、Raft等最大的特點是共識過程無需與其他節點互動，無論是網路中只有1個節點還是成千上萬個節點（目前比特幣的共識（挖礦）節點規模大概在1萬左右），因此它對網路動態變化的適應性非常高。但代價就是需要巨大算力的支援，而傳統共識演算法沒有這種問題。</const></const></const></const></coutpoint></const></const></const></cblocktemplate></uint256></uint256></cblocktemplate></:txiter></int64_t></int64_t></cblocktemplate></ctransactionref></cblocktemplate></ctransactionref></const></const></cblocktemplate>

比特幣挖礦與原始碼解析

相關文章