PoW挖矿算法原理及其在比特币、以太坊中的实现
原文地址:http://blog.51cto.com/9711PoW，全称Proof of Work，即工作量证明，又称挖矿。大部分公有链或虚拟货币，如比特币、以太坊，均基于PoW算法，来实现其共识机制。即根据挖矿贡献的有效工作，来决定货币的分配。 比特币区块 　　比特币区块由区块头和该区块所包含的交易列表组成。区块头大小为80字节，其构成包括： 　　 4字节：版本号　　32字节：上一个区块的哈希值　　32字节：交易列表的Merkle根哈希值　　 4字节：当前时间戳　　 4字节：当前难度值　　 4字节：随机数Nonce值 　　此80字节长度的区块头，即为比特币Pow算法的输入字符串。　　交易列表附加在区块头之后，其中第一笔交易为矿工获得奖励和手续费的特殊交易。 　　bitcoin-0.15.1源码中区块头和区块定义： class CBlockHeader
int32_t nV
uint256 hashPrevB
uint256 hashMerkleR
uint32_t nT
uint32_t nB
uint32_t nN
class CBlock : public CBlockHeader
std::vector&CTransactionRef&
比特币Pow算法原理 　　Pow的过程，即为不断调整Nonce值，对区块头做双重SHA256哈希运算，使得结果满足给定数量前导0的哈希值的过程。　　其中前导0的个数，取决于挖矿难度，前导0的个数越多，挖矿难度越大。 　　具体如下： 　　1、生成铸币交易，并与其它所有准备打包进区块的交易组成交易列表，生成Merkle根哈希值。　　2、将Merkle根哈希值，与区块头其它字段组成区块头，80字节长度的区块头作为Pow算法的输入。　　3、不断变更区块头中的随机数Nonce，对变更后的区块头做双重SHA256哈希运算，与当前难度的目标值做比对，如果小于目标难度，即Pow完成。 　　Pow完成的区块向全网广播，其他节点将验证其是否符合规则，如果验证有效，其他节点将接收此区块，并附加在已有区块链之后。之后将进入下一轮挖矿。版本号4字节 ：""上一区块哈希值32：
"81cd02ab7e569e8bcdf2de44d49ab2b" 交易列表的Merkle根哈希值32："e320b6c2fffc8db1eb942ae710e951ed797f7affcfc122b" . 当前时间戳 4字节
"c7f5d74d" . 当前难度值 4字节
"f2b9441a" . 随机数Nonce "42a14695"; output: 9a8a21adc5d38d0a473b144bf98bd1d 　　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;
LOCK(cs_main);
nHeight = chainActive.Height();
nHeightEnd = nHeight+nG
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-&
LOCK(cs_main);
IncrementExtraNonce(pblock, chainActive.Tip(), nExtraNonce);
while (nMaxTries & 0 && pblock-&nNonce & nInnerLoopCount && !CheckProofOfWork(pblock-&GetHash(), pblock-&nBits, Params().GetConsensus())) {
++pblock-&nN
if (nMaxTries == 0) {
if (pblock-&nNonce == nInnerLoopCount) {
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");
blockHashes.push_back(pblock-&GetHash().GetHex());
if (keepScript)
coinbaseScript-&KeepScript();
return blockH
　　另附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())
pblock = &pblocktemplate-&
pblock-&vtx.emplace_back();
pblocktemplate-&vTxFees.push_back(-1);
pblocktemplate-&vTxSigOpsCost.push_back(-1);
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 = nBlockW
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] = -nF
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());
pblock-&nNonce
pblocktemplate-&vTxSigOpsCost[0] = WITNESS_SCALE_FACTOR * GetLegacySigOpCount(*pblock-&vtx[0]);
CValidationS
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);
比特币挖矿难度计算 　　每创建2016个块后将计算新的难度，此后的2016个块使用新的难度。计算步骤如下： 　　1、找到前2016个块的第一个块，计算生成这2016个块花费的时间。即最后一个块的时间与第一个块的时间差。时间差不小于3.5天，不大于56天。　　2、计算前2016个块的难度总和，即单个块的难度x总时间。　　3、计算新的难度，即2016个块的难度总和/14天的秒数，得到每秒的难度值。　　4、要求新的难度，难度不低于参数定义的最小难度。 　　bitcoin-0.15.1源码中计算挖矿难度代码如下：
unsigned int CalculateNextWorkRequired(const CBlockIndex* pindexLast, int64_t nFirstBlockTime, const Consensus::Params& params)
if (params.fPowNoRetargeting)
return pindexLast-&nB
int64_t nActualTimespan = pindexLast-&GetBlockTime() - nFirstBlockT
if (nActualTimespan & params.nPowTargetTimespan/4)
nActualTimespan = params.nPowTargetTimespan/4;
if (nActualTimespan & params.nPowTargetTimespan*4)
nActualTimespan = params.nPowTargetTimespan*4;
const arith_uint256 bnPowLimit = UintToArith256(params.powLimit);
arith_uint256 bnN
bnNew.SetCompact(pindexLast-&nBits);
bnNew *= nActualT
bnNew /= params.nPowTargetT
if (bnNew & bnPowLimit)
bnNew = bnPowL
return bnNew.GetCompact();
以太坊区块 　　以太坊区块由Header和Body两部分组成。 　　其中Header部分成员如下：　　ParentHash，父区块哈希　　UncleHash，叔区块哈希，具体为Body中Uncles数组的RLP哈希值。RLP哈希，即某类型对象RLP编码后做SHA3哈希运算。　　Coinbase，矿工地址。　　Root，StateDB中state Trie根节点RLP哈希值。　　TxHash，Block中tx Trie根节点RLP哈希值。　　ReceiptHash，Block中Receipt Trie根节点的RLP哈希值。　　Difficulty，区块难度，即当前挖矿难度。　　Number，区块序号，即父区块Number+1。　　GasLimit，区块内所有Gas消耗的理论上限，创建时指定，由父区块GasUsed和GasLimit计算得出。　　GasUsed，区块内所有Transaction执行时消耗的Gas总和。　　Time，当前时间戳。　　Nonce，随机数Nonce值。 　　有关叔区块：　　叔区块，即孤立的块。以太坊成块速度较快，导致产生孤块。　　以太坊会给发现孤块的矿工以回报，激励矿工在新块中引用孤块，引用孤块使主链更重。在以太坊中，主链是指最重的链。 　　有关state Trie、tx Trie和Receipt Trie：　　state Trie，所有账户对象可以逐个插入一个Merkle-PatricaTrie(MPT)结构中，形成state Trie。　　tx Trie：Block中Transactions中所有tx对象，逐个插入MPT结构中，形成tx Trie。　　Receipt Trie：Block中所有Transaction执行后生成Receipt数组，所有Receipt逐个插入MPT结构中，形成Receipt Trie。 　　Body成员如下：　　Transactions，交易列表。　　Uncles，引用的叔区块列表。 　　go-ethereum-1.7.3源码中区块头和区块定义： type Header struct {
ParentHash
common.Hash
common.Hash
common.Address
common.Hash
common.Hash
ReceiptHash common.Hash
Difficulty
common.Hash
BlockNonce
type Body struct {
Transactions []*Transaction
以太坊Pow算法原理 　　以太坊Pow算法可以表示为如下公式：　　RAND(h, n) &= M / d 　　其中RAND()表示一个概念函数，代表一系列的复杂运算。　　其中h和n为输入，即区块Header的哈希、以及Header中的Nonce。　　M表示一个极大的数，此处使用2^256-1。　　d，为区块难度，即Header中的Difficulty。 　　因此在h和n确定的情况下，d越大，挖矿难度越大，即为Difficulty本义。　　即不断变更Nonce，使RAND(h, n)满足RAND(h, n) &= M / d，即完成Pow。 　　go-ethereum-1.7.3源码中Pow算法实现： func (ethash *Ethash) mine(block *types.Block, id int, seed uint64, abort chan struct{}, found chan *types.Block) {
header = block.Header()
= header.HashNoNonce().Bytes()
target = new(big.Int).Div(maxUint256, header.Difficulty)
= header.Number.Uint64()
dataset = ethash.dataset(number)
attempts = int64(0)
logger := log.New("miner", id)
logger.Trace("Started ethash search for new nonces", "seed", seed)
case &-abort:
logger.Trace("Ethash nonce search aborted", "attempts", nonce-seed)
ethash.hashrate.Mark(attempts)
attempts++
if (attempts % (1 && 15)) == 0 {
ethash.hashrate.Mark(attempts)
attempts = 0
digest, result := hashimotoFull(dataset, hash, nonce)
if new(big.Int).SetBytes(result).Cmp(target) &= 0 {
header = types.CopyHeader(header)
header.Nonce = types.EncodeNonce(nonce)
header.MixDigest = common.BytesToHash(digest)
case found &- block.WithSeal(header):
logger.Trace("Ethash nonce found and reported", "attempts", nonce-seed, "nonce", nonce)
case &-abort:
logger.Trace("Ethash nonce found but discarded", "attempts", nonce-seed, "nonce", nonce)
以太坊挖矿难度计算 　　以太坊每次挖矿均需计算当前区块难度。　　按版本不同有三种计算难度的规则，分别为：calcDifficultyByzantium（Byzantium版）、calcDifficultyHomestead（Homestead版）、calcDifficultyFrontier（Frontier版）。此处以calcDifficultyHomestead为例。 　　计算难度时输入有：　　parent_timestamp：父区块时间戳　　parent_diff：父区块难度　　block_timestamp：当前区块时间戳　　block_number：当前区块的序号 　　当前区块难度计算公式，即： block_diff = parent_diff
+ (parent_diff / 2048 * max(1 - (block_timestamp - parent_timestamp)
+ 2^((block_number
　　其中//为整数除法运算符，a//b，即先计算a/b，然后取不大于a/b的最大整数。 　　调整难度的目的，即为使挖矿时间保持在10-19s期间内，如果低于10s增大挖矿难度，如果大于19s将减小难度。另外，计算出的当前区块难度不应低于以太坊创世区块难度，即131072。 　　go-ethereum-1.7.3源码中计算挖矿难度代码如下： func calcDifficultyHomestead(time uint64, parent *types.Header) *big.Int {
bigTime := new(big.Int).SetUint64(time)
bigParentTime := new(big.Int).Set(parent.Time)
x := new(big.Int)
y := new(big.Int)
x.Sub(bigTime, bigParentTime)
x.Div(x, big10)
x.Sub(big1, x)
if x.Cmp(bigMinus99) & 0 {
x.Set(bigMinus99)
y.Div(parent.Difficulty, params.DifficultyBoundDivisor)
x.Mul(y, x)
x.Add(parent.Difficulty, x)
if x.Cmp(params.MinimumDifficulty) & 0 {
x.Set(params.MinimumDifficulty)
periodCount := new(big.Int).Add(parent.Number, big1)
periodCount.Div(periodCount, expDiffPeriod)
if periodCount.Cmp(big1) & 0 {
y.Sub(periodCount, big2)
y.Exp(big2, y, nil)
x.Add(x, y)
后记 　　Pow算法概念简单，即工作端提交难以计算但易于验证的计算结果，其他节点通过验证这个结果来确信工作端完成了相当的工作量。　　但其缺陷也很明显：1、随着节点将CPU挖矿升级为GPU、甚至矿机挖矿，节点数和算力已渐渐失衡；2、比特币等网络每秒需完成数百万亿次哈希计算，资源大量浪费。　　为此，业内提出了Pow的替代者如PoS权益证明算法，即要求用户拥有一定数量的货币，才有权参与确定下一个合法区块。另外，相对拥有51%算力，购买超过半数以上的货币难度更大，也使得恶意攻击更加困难。
没有更多推荐了，
加入CSDN，享受更精准的内容推荐，与500万程序员共同成长！比特币的挖矿到底在计算什么？_百度知道
比特币的挖矿到底在计算什么？
数学模型是什么？这种计算是不是为了某些别的东西，而比特币只是个附属品?
我有更好的答案
计算的就是比特币本身。这一计算过程就是比特币的发行过程。因上述原因，可以理解为没有实际意义，浪费资源，没有实际投资意义。货币包的数目就是连接的其他客户端的数量（毕竟是P2P），这很重要！这个数值要达到一定程度账户才可正常运作。且需要注意的是目前比特币国内是不承认的，投资需谨慎！
舟山大宗首席分析师
我也想问这个问题，我只能猜想里面是个暗箱！但是对于做传销的人来说，具体内容不重要，神密感更重要！
本回答被提问者采纳
每一个比特币的节点都会收集所有尚未确认的交易，并将其归集到一个数据块中，这个数据块会和前面一个数据块集成在一起。矿工节点会附加一个随机调整数，并计算前一个数据块的SHA-256哈希运算值。挖矿节点不断重复进行尝试，直到它找到的随机调整数使得产生的哈希值低于某个特定的目标。
由于哈希运算是不可逆的，寻找到符合要求的随机调整数非常困难，需要一个可以预计总数的不断试错过程。这时，工作量证明机制就发挥作用了。当一个节点找到了符合要求的解，那么它就可以向全网广播自己的结果。其他节点就可以接收这个新解出来的数据块，并检验其是否符合规格。如果其他节点通过计算哈希值发现确实满足要求，那么该数据块有效，其他节点就会接受该数据块，并将其附加在自己已有的链条之后。
比特币挖矿采用的是SHA-256哈希值运算，这种算法会进行大量的32位整数循环右移运算穷举，验证，直到找到某个符合要求的的数据，这个毫无意义的数据就是一块钱了
本回答被网友采纳
比特币只是计算 计算机漏洞的一种代码
而这个代码就等于漏洞 所以会值钱~
什么也没算，只是用极小的概率生成被发明它的人设定好的一串加密字符串。但是造成计算的假象。你懂的，创造者1元钱卖给第一个人。第一个人10元钱卖给第二个人。第二个人860元钱卖给第三个人。第三个人5630元钱卖给第四个人。。。 。。。直到最后一个人卖不出去。所以它可以来骗钱。
按时大大多少分萨芬
其他3条回答
为您推荐：
其他类似问题
比特的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。查看: 33|回复: 0
比特币挖矿算法具体是什么？
a6fed6bf1b7ad8f07e495e8eb7cd9a4e.jpg (86.17 KB, 下载次数: 0)
00:10 上传
需要以下参数
1、block的版本version
2、上一个block的hash值: prev_hash
3、需要写入的交易记录的hash树的值: merkle_root
4、更新时间: ntime
5、当前难度: nbits
挖矿的过程就是找到x使得
SHA256(SHA256(version + prev_hash + merkle_root + ntime + nbits + x )) &TARGET
上式的x的范围是0~2^32,TARGET可以根据当前难度求出的。除了x之外，你还可以尝试改动merkle_root和ntime。由于hash的特性，找这样一个x只能暴力搜索。
一旦你找到了x，你就可以广播一个新的block，其他客户端会验证你的block是否合法。如果你的block被接受，由于每个block中的第一笔交易必须是将新产生25个比特币发送到某个地址，当然你会把这个地址设为你所拥有的地址来得到这25个比特币。
比特币从开始到现在的每一笔交易记录都保存在网络上，整个比特币网络维护的一个巨大的交易记录文件(现在大约12G)。这个文件的更新周期平均是10分钟，新加入的交易记录叫做一个block，而这个硕大的文件由一串block组成，叫做block chain.
为什么是25个比特币?
这是规定。最初是50个比特币，每产生剩下比特币的一半，这个所得就会减半，这样最终能产生的比特币总量趋近于2100万。如果你现在仍然声称挖到了50个比特币，这是不会被其他客户端接受的，这个block就算白挖了。
怎么保证更新周期平均是10分钟?
TARGET越小，解出x的难度就越大，每产生2016个block(约14天)，网络会根据这段时间产生新block的平均间隔调整之后的TARGET。
是不是计算速度最快的人总是先解出来?
不是。你总是想把挖矿所得据为己有，所以每个人在计算时，发送挖矿所得的地址是不一样的，这样merkle_root就不同，也就是说每个人是从不同的初始状态开始求解的。
同时解出来怎么办?
blockchain会出现分叉，部分客户端接受了A，部分接受了B，直到某个分支变得更长，所有人就会选择这个更长的分支。如果你挖出来的不幸没有被选中，你的挖矿所得就无效了。
既然选更长的分支，那我用很低的难度去求解怎么办?
客户端在众多分支中找到符合当前难度且最长的。
这些计算浪费了吗?
如果你要把一笔钱花两次，你需要这么做。挖到一个新的block，但是藏着不广播，并继续挖矿。找到商家A，支付比特币，让网络上的其他人挖到block并写入这笔交易记录。找到商家B，支付比特币，写入自己挖的block。如果你能抢先挖到两个block并广播出去，所有人会以你这个更长的分支为当前的blockchain，商家A收到的比特币就不被承认了。这样攻击成功的概率取决于你计算hash的速度。整个网络的计算力足够高的话，这样的攻击或者成功率极低，或者成本极大。
相关热门帖子推荐
主题帖子积分
屌丝, 积分 0, 距离下一级还需 100 积分
屌丝, 积分 0, 距离下一级还需 100 积分
热门推荐联系客服
好币推荐 /1
Coinex也推出了交易挖矿，6月20日9点刚出公告，短短10分钟就爆升560%，持币分红的模式。7月1日正式上线。平台币CET现价只有0.3元，升值空间巨大。点击注册并立即买入CET，以小博大。
( 鄂ICP备号-1 )
赚币吧致力于中国区块链人气最旺的区块链论坛.Powered by Discuz!.
所有言论仅供参考，不可作为交易操作依据，请广大用户谨慎决策，注意投资风险。
用微信扫一扫推荐内容RECOMMEND
热门文章HOT ARTICLES比特币挖矿中POW是什么？是怎么工作的呢？比特币挖矿中POW是什么？是怎么工作的呢？知识决定命百家号在通过"挖矿"得到比特币的过程中，我们需要找到其相应的解m，而对于任何一个六十四位的哈希值，要找到其解m，都没有固定算法，只能靠计算机随机的hash碰撞，而一个挖矿机每秒钟能做多少次hash碰撞，就是其"算力"的代表，单位写成hash/s,这就是所谓工作量证明机制POW(Proof Of Work)。每一个比特币区块链中的区块都包含着一个由无意义数据构成的短字符串（称为随机数）。只有挖矿设备搜索到正确的无意义字符串，区块作为一个整体才能满足某个随机条件（arbitrary condition）而生成。具体地说就是，区块的SHA-256哈希函数中必须有一定数量的前导零。由于哈希函数是单行函数，因此找正确的随机数或者说让区块满足相应的条件都没有简单的方法。找到一个合适的随机数唯一已知的方法是不停地随机试探直到搜索到一个有效的数。Khan Academy对工作量证明给出了形象生动的解释。通俗的讲究是这些数据都是随机的，我们要不停的去碰。整个过程都是随机的，为了使区块生成这个过程是有难度的，哈希值是六十四位数的，要想解这个M值，就要不停的去hash碰撞。挖矿设备是用来帮区块链记账的，但其实它们的实际所做的大部分工作是寻找正确的随机数而与记账无关。本文由百家号作者上传并发布，百家号仅提供信息发布平台。文章仅代表作者个人观点，不代表百度立场。未经作者许可，不得转载。知识决定命百家号最近更新：简介:若是有缘
自会相见作者最新文章相关文章}