这里介绍工作量证明POW， POW是属于共识机制的内容。! U8 R# B& n+ k2 I5 r. }. K
PoW机制中根据矿工的工作量来执行货币的分配和记账权的确定。算力竞争的胜者将获得相应区块记账权和比特币奖励。因此,矿机芯片的算力越高,挖矿的时间更长,就可以获得更多的数字货币。
* l# j9 p) |1 \0 J3 i优点：" i- c* u+ X% n
算法简单，容易实现；节点间无需交换额外的信息即可达成共识；破坏系统需要投入极大的成本。$ C6 r1 Q6 ^6 {  Q! l, i4 G
缺点：7 }. X8 ^+ c* w0 N& \+ d6 ~; n
浪费能源；区块的确认时间难以缩短；新的区块链必须找到一种不同的散列算法，否则就会面临比特币的算力攻击；容易产生分叉，需要等待多个确认；永远没有最终性，需要检查点机制来弥补最终性。
/ ~4 Q8 _! m1 J0 G7 b3 i目前基于PoW共识机制的数字货币有很多，比特币、莱特币、狗狗币、达士币、门罗币等初期的数字货币大多都是PoW共识机制。
" r( s7 v0 I6 c, T& ?  X其他的共识机制还有
2 e/ Z" ?/ R4 n, Y' g2 _) W7 ?. LPoS（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共识机制
: Y) }! ~1 Y3 E* z3 ~# U) H
1 y/ U+ Z' n7 e% C, p这些共识机制，后面有时间会补充上的，今天主要介绍POW
3 r: y1 i6 b0 \! a, T. h: `. epow很简单，原理就是 利用计算力，在选择一个nonce的值结合区块的数据算出hash，使得hash的前面多少位都是0.* ^" d- j2 F' P8 o8 p# z
nonce是一个用来找到满足条件的hash值的数字，nonce值一直迭代，直到hash值有效为止。在我们案例中一个有效的hash值是最少有4个前导0。找到nonce值以满足合适条件的hash值的过程就叫做挖矿。  x; n; T: y5 _% w5 Y
下面给出代码：
" K/ [2 O  q) O: R; n5 a4 A

1. golang版
   - S( u. E, a6 q$ e% O! ^7 _
2. package mainimport (    "bytes"/ I% C' C) \: U* i7 R
   
3.     "crypto/sha256"  i3 m1 B7 b1 l% ]
   
4.     "fmt"3 m) e2 h7 X7 T, Y% l: |
   
5.     "math"; M$ }- [! D9 G1 X
   
6.     "math/big")// 前导0，难度const targetBits  = 8type ProofOfWork struct {, X' n# ?7 S/ \3 y, T0 B
   
7.     block *Block" _9 P6 q. W. ?( s: d
   
8.     targetBit *big.Int
   & h; L9 q* h, }2 o; Z# m
9. }func NewProofOfWork(block *Block) *ProofOfWork  {    // 设置64位全18 k( M( ]2 X; v( S* T
   
10.     var IntTarget = big.NewInt(1)    //00000000000000000000000000001
    4 R6 T. F( ^3 f
11.     //10000000000000000000000000000
    9 q# P! T  t  e& B
12.     //000000000001000000000000000008 h. c$ d( P4 q. ?' S; d
    
13.     //0000001. {- U6 T' Z3 b+ \8 W
    
14.     // 右移 targetBits位3 n# I) y, |( Z; [, C
    
15.     IntTarget.Lsh(IntTarget, uint(256 - targetBits))    return &ProofOfWork{block:block, targetBit:IntTarget}  N, }5 f' ~+ R: Q' K" a( ^
    
16. }func (pow *ProofOfWork)PrepareRawData(nonce int64)[]byte  {
    ( h, y" n5 ^% A1 k
17.     block := pow.block
    4 C% z- C& {! s3 N) ^
18.     tmp := [][]byte{
    2 z7 Q& r0 k0 s
19.         Int2Byte(block.Version),
    ) X+ m9 b* \0 j' K4 n  ~, w
20.         block.PrevBlockHash,
    ) M. D! @! b' `2 h0 Z
21.         Int2Byte(block.TimeStamp),$ M. U! I  m; a) S3 e
    
22.         block.MerkeRoot,- C  y% _# T  Q( h5 q1 F
    
23.         Int2Byte(nonce),$ N, z  e7 u. F5 b3 V4 O, H% f
    
24.         Int2Byte(targetBits),
    $ M) g7 g/ z5 [# {: s9 p
25.         block.Data}9 H6 M8 E7 c- r" e- X, |* t6 u) R
    
26.     data := bytes.Join(tmp, []byte{})    return data
    . M9 j) I! w; ?/ i! u' z" E+ m
27. }func (pow *ProofOfWork)Run() (int64, []byte) {    var nonce int64
    % N7 S. D$ k% r* h; o! n( e
28.     var hash [32]byte
    7 F7 q% K% Q' O# d3 p
29.     var HashInt big.Int. e3 ?- x" u! |6 S8 `) {1 l
    
30.     fmt.Printf("target hash:", pow.targetBit.Bytes())    for nonce
    6 }; P- s4 q& o( A' D+ `; C/ N
31. python版
    5 q* [  t3 w; r; L- O9 `. K
32. function isValidHashDifficulty(hash, difficulty) {  for (var i = 0, b = hash.length; i = difficulty;$ I6 K! K6 x9 ~
    
33. }import hashlib"""3 @) I9 b8 C6 l5 T' f0 W8 R
    
34. 工作量证明
    % X5 U- T/ z* C1 d
35. """class ProofofWork():
    % X* y. U8 i2 A. K
36.     """- @% v0 G2 K) k2 _+ h
    
37.     pow
    1 I# v$ O% t' |$ F5 [4 S( a
38.     """0 i, M9 u; N5 f4 ^
    
39.     def __init__(self, block):1 ?$ K& |3 I7 A2 |9 Y* q( B* r
    
40.         self.block = block    def mine(self):. z2 {5 U* J1 n; K0 f  j
    
41.         """- V$ R7 k/ c/ Q6 I6 T! r
    
42.         挖矿函数" ~6 I/ |. m. Q
    
43.         :return:7 e! }5 b% G3 W5 I
    
44.         """
    # `$ s) a6 V5 G
45.         i = 0
    / k% [9 f: h5 k1 u, S
46.         prefix = '0000'
    + C8 P- i  b1 S! }3 [; o
47.         while True:4 W2 x, F( u1 K  ]& m, y
    
48.             nonce = str(i)& X2 ~" D, j; Q9 c9 h8 \1 A
    
49.             message = hashlib.sha256()
    5 t* i$ X* Q: t1 f7 {0 R
50.             message.update(str(self.block.data).encode('utf-8'))
    $ Z) r' W0 q0 K* _1 m& F# N
51.             message.update(nonce.encode("utf-8"))
      n, Z/ V% v. d0 d2 V( q- w$ ^
52.             digest = message.hexdigest()            if digest.startswith(prefix):                return nonce, digest
    ( Q3 l" k5 H1 b5 h$ r- j# E
53.             i += 16 n0 l* \% O; c
    

复制代码