区块链POW证明代码实现demo

这里介绍工作量证明POW， POW是属于共识机制的内容。
PoW机制中根据矿工的工作量来执行货币的分配和记账权的确定。算力竞争的胜者将获得相应区块记账权和比特币奖励。因此,矿机芯片的算力越高,挖矿的时间更长,就可以获得更多的数字货币。
优点：
算法简单，容易实现；节点间无需交换额外的信息即可达成共识；破坏系统需要投入极大的成本。
缺点：
浪费能源；区块的确认时间难以缩短；新的区块链必须找到一种不同的散列算法，否则就会面临比特币的算力攻击；容易产生分叉，需要等待多个确认；永远没有最终性，需要检查点机制来弥补最终性。
目前基于PoW共识机制的数字货币有很多，比特币、莱特币、狗狗币、达士币、门罗币等初期的数字货币大多都是PoW共识机制。
其他的共识机制还有
PoS（Proof of Stake）DPOS（Delegated Proof-of-Stake）DAG(Directed acyclic graph)PBFT（Practical Byzantine Fault Tolerance）Pool验证池dBFT（delegated BFT）PoA（Proof-of-Authority）RPCA（Ripple Protocol consensus algorithm）Hcash——PoW+PoS共识机制

这些共识机制，后面有时间会补充上的，今天主要介绍POW
pow很简单，原理就是利用计算力，在选择一个nonce的值结合区块的数据算出hash，使得hash的前面多少位都是0.
nonce是一个用来找到满足条件的hash值的数字，nonce值一直迭代，直到hash值有效为止。在我们案例中一个有效的hash值是最少有4个前导0。找到nonce值以满足合适条件的hash值的过程就叫做挖矿。
下面给出代码：

golang版
) D" Z/ w# v. p4 h* _4 W4 x @
package mainimport ( "bytes"1 C4 D* E0 d% D' P
"crypto/sha256"& F. ^; i3 m8 x: n
"fmt"
! H! }* s0 J" \' X/ j
"math"
0 R& m; X1 ^9 v: d8 I1 c+ K
"math/big")// 前导0，难度const targetBits = 8type ProofOfWork struct { x$ t, ^- X) a/ L* C; I: r1 I
block *Block
5 ]+ ^: Z5 W; a8 i. ?
targetBit *big.Int
; ^* O: \/ |1 C. k# `
}func NewProofOfWork(block *Block) *ProofOfWork { // 设置64位全10 f) e' B7 \/ e
var IntTarget = big.NewInt(1) //00000000000000000000000000001. O4 _" c2 \1 B- q) m0 I, F4 A
//100000000000000000000000000001 g; v7 B/ C B# n
//00000000000100000000000000000
/ x4 y, Y# Q: I8 E7 P3 o
//0000001
1 D8 X* F" _/ f+ _5 N2 y, i, G3 }
// 右移 targetBits位1 R1 a) h* Z, g& `; O
IntTarget.Lsh(IntTarget, uint(256 - targetBits)) return &ProofOfWork{block:block, targetBit:IntTarget}
4 _4 q; h, C- T
}func (pow *ProofOfWork)PrepareRawData(nonce int64)[]byte {' L) W0 s" ^9 m3 @! F( _4 l# w( ~
block := pow.block
% C" W/ z1 w4 a ^ c1 E' |
tmp := [][]byte{/ s! I, ^* i# C9 j+ @+ g: I
Int2Byte(block.Version),. i: H- m! `( Y4 [$ g [/ G
block.PrevBlockHash,
* e9 R8 G( f6 D& _9 C, N h* o
Int2Byte(block.TimeStamp),
% n. H- o. g% o5 o
block.MerkeRoot,* h$ S( g! C$ A
Int2Byte(nonce),4 M I; ~4 n( U$ t. s$ M- b
Int2Byte(targetBits),) x& K9 d( U. T" p+ x& K
block.Data}; I& y( m, j( [! Q1 g
data := bytes.Join(tmp, []byte{}) return data
0 x9 [1 ?/ P" x% b7 k
}func (pow *ProofOfWork)Run() (int64, []byte) { var nonce int64 v, v+ n- D* X! _+ ]: i6 Z; ^
var hash [32]byte
: G; d9 L3 y2 d; G/ O* M+ R* a' X
var HashInt big.Int
, L9 h) M8 O$ N5 ^) G
fmt.Printf("target hash:", pow.targetBit.Bytes()) for nonce
% Z- Q0 ^8 \ N1 `3 E: @1 O) G( s
python版
( `' O$ {" J0 B, T* ]; b
function isValidHashDifficulty(hash, difficulty) { for (var i = 0, b = hash.length; i = difficulty;
& O7 g3 _4 o/ [ R7 f( s1 z5 M
}import hashlib"""' V9 c C5 ?' p6 P O1 L& k
工作量证明
; a7 L; n2 F9 Z+ A; Z7 A( Y
"""class ProofofWork():+ ^0 H/ k- d: C; B$ w) ^
"""
& A5 E# q2 r* r6 D. B
pow
6 _' H7 |3 f8 a1 \9 w' M0 ?/ F
"""' K' H( S, u. e7 W! I0 i( V1 P
def __init__(self, block):6 \- i m7 M @2 }) b$ p0 d" _7 g: R
self.block = block def mine(self):
6 f7 \# R F7 f p
"""
% O o8 X3 A' H4 @! `
挖矿函数
6 a8 T) f. e6 g: {
:return:
"""
( V) q1 Y/ y; j0 x
i = 0
4 T+ v+ E% O( ]% w
prefix = '0000'
$ b4 Q! M" Z& k5 W6 ]
while True:0 u# }; x1 |/ ^" ?+ c& ~$ Q2 ~) Z" R
nonce = str(i)
! l5 L9 W1 D. d* O( y
message = hashlib.sha256(). _4 G2 E- C! E; J% t! z
message.update(str(self.block.data).encode('utf-8'))5 O! a- Y0 z e' V( j
message.update(nonce.encode("utf-8"))
* @: V* s+ D; h a, j6 d- \
digest = message.hexdigest() if digest.startswith(prefix): return nonce, digest
/ D: f8 G: A3 M4 T( {1 B7 `0 A* B
i += 1
8 }' D @& Y4 `; r, a6 s

复制代码

浏览过的版块