这里介绍工作量证明POW， POW是属于共识机制的内容。
5 L  H$ d9 c- `$ ~, y. e' lPoW机制中根据矿工的工作量来执行货币的分配和记账权的确定。算力竞争的胜者将获得相应区块记账权和比特币奖励。因此,矿机芯片的算力越高,挖矿的时间更长,就可以获得更多的数字货币。
2 w$ t' |& k" M$ g优点：) Q6 \$ B6 h) U+ J& q6 _
算法简单，容易实现；节点间无需交换额外的信息即可达成共识；破坏系统需要投入极大的成本。
) S- l0 E8 l' ]4 g缺点：
" v0 l% C2 [8 B& k7 R* v7 S浪费能源；区块的确认时间难以缩短；新的区块链必须找到一种不同的散列算法，否则就会面临比特币的算力攻击；容易产生分叉，需要等待多个确认；永远没有最终性，需要检查点机制来弥补最终性。% |6 A( f% P# P& h
目前基于PoW共识机制的数字货币有很多，比特币、莱特币、狗狗币、达士币、门罗币等初期的数字货币大多都是PoW共识机制。
0 D, T1 Q9 d2 x, p; l% B4 N其他的共识机制还有
# [" h  \0 }$ f* V# jPoS（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共识机制  S& M& x, s; Y. {2 b4 X- y- r

+ Z8 g! A' e' c( X) e. s4 a8 z8 K这些共识机制，后面有时间会补充上的，今天主要介绍POW+ E6 d$ `) i7 B5 t, V
pow很简单，原理就是 利用计算力，在选择一个nonce的值结合区块的数据算出hash，使得hash的前面多少位都是0.3 D( s) Y2 {" u8 T+ l
nonce是一个用来找到满足条件的hash值的数字，nonce值一直迭代，直到hash值有效为止。在我们案例中一个有效的hash值是最少有4个前导0。找到nonce值以满足合适条件的hash值的过程就叫做挖矿。
6 b9 H# f7 }$ z, L下面给出代码：
; b6 w3 _; M/ o! V0 A5 n

1. golang版
   ! v; n( p6 H2 ^- F
2. package mainimport (    "bytes"! d- T* ~1 X  _7 |
   
3.     "crypto/sha256"+ P# |3 W# V2 E7 U
   
4.     "fmt". p  x+ k) x- |; z) a2 S& @7 X
   
5.     "math"; G/ ~: I4 p. }1 m* k' N
   
6.     "math/big")// 前导0，难度const targetBits  = 8type ProofOfWork struct {3 n4 j( G9 e- {
   
7.     block *Block2 l* A) _' ^' |: J9 W6 z
   
8.     targetBit *big.Int/ u# |1 e+ D7 h* |. d: X
   
9. }func NewProofOfWork(block *Block) *ProofOfWork  {    // 设置64位全1; W+ g3 \4 s/ T+ b
   
10.     var IntTarget = big.NewInt(1)    //00000000000000000000000000001
    # ~' x/ a( B6 U# U
11.     //10000000000000000000000000000/ I, e- _! z" i$ V; o6 N
    
12.     //00000000000100000000000000000
    ' i# S2 ?8 M+ q' I: [" Y
13.     //0000001& Y# e/ K0 ~6 {( D/ Y, G7 P
    
14.     // 右移 targetBits位
    ) |  I* s0 t( e( J: ^
15.     IntTarget.Lsh(IntTarget, uint(256 - targetBits))    return &ProofOfWork{block:block, targetBit:IntTarget}% ~+ ~& y! O( |8 ^
    
16. }func (pow *ProofOfWork)PrepareRawData(nonce int64)[]byte  {
    9 A3 L) r$ n7 J
17.     block := pow.block
    , ]' G$ g1 R( u% N
18.     tmp := [][]byte{
    * q3 c( z/ {3 s( t/ L
19.         Int2Byte(block.Version),' X% j5 K  e# M3 ?6 `
    
20.         block.PrevBlockHash,0 \, \+ {; c7 ~7 L6 B9 V
    
21.         Int2Byte(block.TimeStamp),
    5 e/ K" ^' ~9 W3 K+ _* t# F
22.         block.MerkeRoot,% ^/ f- K7 Q- G! l  ^+ z, ?
    
23.         Int2Byte(nonce),: j3 m" N4 k) O# ]" ~
    
24.         Int2Byte(targetBits),
    8 d2 c( V7 k- N) o  r4 Q+ [: Y
25.         block.Data}
    - H: ]. w# s- i; H- B  y8 s
26.     data := bytes.Join(tmp, []byte{})    return data8 i. O3 ]& w/ V$ F$ b" N' e9 {
    
27. }func (pow *ProofOfWork)Run() (int64, []byte) {    var nonce int64: E4 g& Z# g# |' W# d9 u! b
    
28.     var hash [32]byte
    2 {1 ^/ |; n$ Q  w" [
29.     var HashInt big.Int
    0 C4 Z/ T5 e9 g" l# w/ |
30.     fmt.Printf("target hash:", pow.targetBit.Bytes())    for nonce
    , G+ t( E7 X& G9 l
31. python版1 f$ I, u* \; M% J) h
    
32. function isValidHashDifficulty(hash, difficulty) {  for (var i = 0, b = hash.length; i = difficulty;  t# S4 q; t5 Q2 Y3 v$ A( C  C
    
33. }import hashlib"""  Z) W( l, I& j  W
    
34. 工作量证明0 P! h# ~# u- I. F
    
35. """class ProofofWork():
    4 O2 E# u& o; y
36.     """" c! P/ C  s8 {& {2 P
    
37.     pow
    $ p. V# l$ n. P. K/ D$ N
38.     """& }, T" e7 E' Y6 R
    
39.     def __init__(self, block):
    7 T, T4 u/ I$ k
40.         self.block = block    def mine(self):5 I6 `9 G. F3 o+ e1 X
    
41.         """
    ' C$ i: G( X' W% a& _/ y1 t  }
42.         挖矿函数  {  u' y+ B+ ]* {5 @
    
43.         :return:6 B! L' X. Z3 E4 m
    
44.         """( _0 P$ ]' ~; c3 O' W+ L& r( f  a
    
45.         i = 02 `: b; G& ]; d
    
46.         prefix = '0000'
    ) `' x' V* K  i! E
47.         while True:" ~) G, L! z9 N7 J+ s' P7 w1 F
    
48.             nonce = str(i)4 K% g# `1 R& h8 I# g0 F5 t  f
    
49.             message = hashlib.sha256()
    : Y# O; V& T1 T. G: b- H
50.             message.update(str(self.block.data).encode('utf-8'))
    0 c! k# h0 c- I! C' o0 p
51.             message.update(nonce.encode("utf-8"))
    7 M4 x: B0 M7 R- N7 H! {/ i& R
52.             digest = message.hexdigest()            if digest.startswith(prefix):                return nonce, digest
    7 O% Q6 {9 k7 O2 S$ d: A
53.             i += 1
    ! s% K  |' n2 e0 W6 o# K5 f1 K. \8 @

复制代码