比特幣網路中任何一個節點，如果想生成一個新的區塊並寫入區塊鏈，必須解出比特幣網路出的工作量證明的迷題。這道題關鍵的三個要素是工作量證明函式、區塊及難度值。工作量證明函式是這道題的計算方法，區塊決定了這道題的輸入資料，難度值決定了這道題的所需要的計算量。

工作量證明函式

SHA是安全雜湊演算法（Secure Hash Algorithm）的縮寫，是一個密碼雜湊函式家族。這一組函式是由美國國家安全域性（NSA）設計，美國國家標準與技術研究院（NIST） 釋出的，主要適用於數字簽名標準。SHA256就是這個函式家族中的一個，是輸出值為256位的雜湊演算法。到目前為止，還沒有出現對SHA256演算法的有效攻擊。

區塊

比特幣區塊由區塊頭和該區塊所包含的交易列表組成。區塊頭大小為80位元組，其構成包括：

　　 4位元組：版本號
　　32位元組：上一個區塊的雜湊值
　　32位元組：交易列表的Merkle根雜湊值
　　 4位元組：當前時間戳
　　 4位元組：當前難度值
　　 4位元組：隨機數Nonce值
此80位元組長度的區塊頭，即為比特幣Pow演算法的輸入字串。交易列表附加在區塊頭之後，其中第一筆交易為礦工獲得獎勵和手續費的特殊交易。

bitcoin-0.15.1原始碼中區塊頭和區塊定義

class CBlockHeader
{
public:
    //版本號
    int32_t nVersion;
    //上一個區塊的雜湊值
 

    uint256 hashPrevBlock;
    //交易列表的Merkle根雜湊值
    uint256 hashMerkleRoot;
    //當前時間戳
    uint32_t nTime;
    //當前挖礦難度，nBits越小難度越大
    uint32_t nBits;
    //隨機數Nonce值
    uint32_t nNonce;
    //其它程式碼略
};

class CBlock : public CBlockHeader
{
public:
    //交易列表
    std::vector<CTransactionRef> vtx;
    //其它程式碼略
 

};
//程式碼位置src/primitives/block.h

難度值

難度值（difficulty）是礦工們在挖礦時候的重要參考指標，它決定了礦工大約需要經過多少次雜湊運算才能產生一個合法的區塊。比特幣的區塊大約每10分鐘生成一個，如果要在不同的全網算力條件下，新區塊的產生保持都基本這個速率，難度值必須根據全網算力的變化進行調整。簡單地說，難度值被設定在無論挖礦能力如何，新區塊產生速率都保持在10分鐘一個。

難度的調整是在每個完整節點中獨立自動發生的。每2016個區塊，所有節點都會按統一的公式自動調整難度，這個公式是由最新2016個區塊的花費時長與期望時長（期望時長為20160分鐘即兩週，是按每10分鐘一個區塊的產生速率計算出的總時長）比較得出的，根據實際時長與期望時長的比值，進行相應調整（或變難或變易）。也就是說，如果區塊產生的速率比10分鐘快則增加難度，比10分鐘慢則降低難度。

這個公式可以總結為如下形式：

新難度值 = 舊難度值 * ( 過去2016個區塊花費時長 / 20160 分鐘 )

工作量證明需要有一個目標值。比特幣工作量證明的目標值（Target）的計算公式如下：

目標值 = 最大目標值 / 難度值
其中最大目標值為一個恆定值：
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

目標值的大小與難度值成反比。比特幣工作量證明的達成就是礦工計算出來的區塊雜湊值必須小於目標值。

比特幣工作量證明的過程，就是通過不停的變換區塊頭（即嘗試不同的nouce值）作為輸入進行SHA256雜湊運算，找出一個特定格式雜湊值的過程（即要求有一定數量的前導0）。而要求的前導0的個數越多，代表難度越大。

bitcoin-0.15.1原始碼中計算挖礦難度程式碼如下：

//nFirstBlockTime即前2016個塊的第一個塊的時間戳
unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
{
    if (params.fPowNoRetargeting)
        return pindexLast->nBits;

    //計算生成這2016個塊花費的時間
    int64_t nActualTimespan = pindexLast->GetBlockTime() - nFirstBlockTime;
    //不小於3.5天
    if (nActualTimespan < params.nPowTargetTimespan/4)
        nActualTimespan = params.nPowTargetTimespan/4;
    //不大於56天
    if (nActualTimespan > params.nPowTargetTimespan*4)
        nActualTimespan = params.nPowTargetTimespan*4;

    // Retarget
    const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
    arith_uint256 bnNew;
    bnNew.SetCompact(pindexLast->nBits);
    //計算前2016個塊的難度總和
    //即單個塊的難度*總時間
    bnNew *= nActualTimespan;
    //計算新的難度
    //即2016個塊的難度總和/14天的秒數
    bnNew /= params.nPowTargetTimespan;

    //bnNew越小，難度越大
    //bnNew越大，難度越小
    //要求新的難度，難度不低於引數定義的最小難度
    if (bnNew > bnPowLimit)
        bnNew = bnPowLimit;

    return bnNew.GetCompact();
}
//程式碼位置src/pow.cpp

工作量證明的過程

我們可以把比特幣礦工解這道工作量證明迷題的步驟大致歸納如下：

1. 生成Coinbase交易，並與其他所有準備打包進區塊的交易組成交易列表，通過Merkle Tree演算法生成Merkle Root Hash

2. 把Merkle Root Hash及其他相關欄位組裝成區塊頭，將區塊頭的80位元組資料（Block Header）作為工作量證明的輸入

3. 不停的變更區塊頭中的隨機數即nonce的數值，並對每次變更後的的區塊頭做雙重SHA256運算（即SHA256(SHA256(Block_Header))），將結果值與當前網路的目標值做對比，如果小於目標值，則解題成功，工作量證明完成。

Pow完成的區塊向全網廣播，其他節點將驗證其是否符合規則，如果驗證有效，其他節點將接收此區塊，並附加在已有區塊鏈之後。之後將進入下一輪挖礦。

bitcoin-0.15.1原始碼中Pow演算法實現：

UniValue generateBlocks(std::shared_ptr<CReserveScript> coinbaseScript, int nGenerate, uint64_t nMaxTries, bool keepScript)
{
    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)
    {
        std::unique_ptr<CBlockTemplate> pblocktemplate(BlockAssembler(Params()).CreateNewBlock(coinbaseScript->reserveScript));
        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);
        }
        //不斷變更區塊頭中的隨機數Nonce
        //對變更後的區塊頭做雙重SHA256雜湊運算
        //與當前難度的目標值做比對，如果小於目標難度，即Pow完成
        //uint64_t nMaxTries = 1000000;即重試100萬次
        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());

        //mark script as important because it was used at least for one coinbase output if the script came from the wallet
        if (keepScript)
        {
            coinbaseScript->KeepScript();
        }
    }
    return blockHashes;
}
//程式碼位置src/rpc/mining.cpp

另附bitcoin-0.15.1原始碼中生成鑄幣交易和建立新塊：

std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& scriptPubKeyIn, bool fMineWitnessTx)
{
    int64_t nTimeStart = GetTimeMicros();

    resetBlock();

    pblocktemplate.reset(new CBlockTemplate());

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

    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();
    nHeight = pindexPrev->nHeight + 1;

    //版本號
    pblock->nVersion = ComputeBlockVersion(pindexPrev, chainparams.GetConsensus());
    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();
    fIncludeWitness = IsWitnessEnabled(pindexPrev, chainparams.GetConsensus()) && fMineWitnessTx;

    int nPackagesSelected = 0;
    int nDescendantsUpdated = 0;
    addPackageTxs(nPackagesSelected, nDescendantsUpdated);

    int64_t nTime1 = GetTimeMicros();

    nLastBlockTx = nBlockTx;
    nLastBlockWeight = nBlockWeight;

    //建立鑄幣交易
    CMutableTransaction coinbaseTx;
    coinbaseTx.vin.resize(1);
    coinbaseTx.vin[0].prevout.SetNull();
    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));
    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);

    //上一個區塊的雜湊值
    pblock->hashPrevBlock  = pindexPrev->GetBlockHash();
    UpdateTime(pblock, chainparams.GetConsensus(), pindexPrev);
    //當前挖礦難度
    pblock->nBits          = GetNextWorkRequired(pindexPrev, pblock, chainparams.GetConsensus());
    //隨機數Nonce值
    pblock->nNonce         = 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);
}
//程式碼位置src/miner.cpp