这里介绍工作量证明POW， POW是属于共识机制的内容。4 ~7 R9 N# ?+ \8 H. j2 Z% ~# V! F
PoW机制中根据矿工的工作量来执行货币的分配和记账权的确定。算力竞争的胜者将获得相应区块记账权和比特币奖励。因此,矿机芯片的算力越高,挖矿的时间更长,就可以获得更多的数字货币。1 f! H- i) q! o) t: B8 a& X. ^* U+ j
优点：
$ x3 H+ G; O1 R: }6 j/ D算法简单，容易实现；节点间无需交换额外的信息即可达成共识；破坏系统需要投入极大的成本。3 w4 m7 q' H3 M
缺点：
* F% X* \, X2 [. E' B& p浪费能源；区块的确认时间难以缩短；新的区块链必须找到一种不同的散列算法，否则就会面临比特币的算力攻击；容易产生分叉，需要等待多个确认；永远没有最终性，需要检查点机制来弥补最终性。
7 y" {4 R% b" [7 w7 W- F目前基于PoW共识机制的数字货币有很多，比特币、莱特币、狗狗币、达士币、门罗币等初期的数字货币大多都是PoW共识机制。
# Z+ w. W9 B* y! f: c$ z其他的共识机制还有/ Q% c' Y* I; k: c$ Q
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共识机制# q5 x7 x- ~% d$ M6 l7 t% ~" z. _4 U

) {. Q& g1 H: l2 z* b& _这些共识机制，后面有时间会补充上的，今天主要介绍POW
) w4 a% f% m, K0 I. N8 Q' M$ Apow很简单，原理就是 利用计算力，在选择一个nonce的值结合区块的数据算出hash，使得hash的前面多少位都是0.
, W' T% K& A8 T+ ononce是一个用来找到满足条件的hash值的数字，nonce值一直迭代，直到hash值有效为止。在我们案例中一个有效的hash值是最少有4个前导0。找到nonce值以满足合适条件的hash值的过程就叫做挖矿。
1 J, u% j1 W. H# s3 Q下面给出代码：; O- H" _; j0 v: g

1. golang版
   * @& }  h- R7 p) a8 P
2. package mainimport (    "bytes"
   / f0 A+ Q1 H% A3 ~; U: \% g
3.     "crypto/sha256"2 V  Q( r- o& d8 T
   
4.     "fmt"8 K  f2 c' l) Z8 ?8 [; Q1 }$ P
   
5.     "math"  Q/ o) b1 z% U' S( n
   
6.     "math/big")// 前导0，难度const targetBits  = 8type ProofOfWork struct {4 L1 g" G5 d) w3 F- C" s! t0 _* B
   
7.     block *Block5 k* Z# T, l* J0 _4 l, l
   
8.     targetBit *big.Int
   $ Y0 N$ P2 L1 m- @: B+ x
9. }func NewProofOfWork(block *Block) *ProofOfWork  {    // 设置64位全1- {4 V" \1 d  c
   
10.     var IntTarget = big.NewInt(1)    //00000000000000000000000000001" Z  m4 c7 V2 t& `7 s% O
    
11.     //10000000000000000000000000000. m- j( z7 n" `- |, g
    
12.     //00000000000100000000000000000
    3 [3 V% R& b( r# o
13.     //0000001  q5 C" u' h3 \" F" J. P( B
    
14.     // 右移 targetBits位5 A, M6 p; n' c
    
15.     IntTarget.Lsh(IntTarget, uint(256 - targetBits))    return &ProofOfWork{block:block, targetBit:IntTarget}: I9 B2 U. F+ c6 e3 ]* a  v8 }
    
16. }func (pow *ProofOfWork)PrepareRawData(nonce int64)[]byte  {
      z& t# o/ n& q! e2 g" L. ^
17.     block := pow.block
    / @" s" y  E# K0 j7 Z$ S
18.     tmp := [][]byte{' X$ e. i9 A* Q) a9 p& Z0 _/ E" x
    
19.         Int2Byte(block.Version),
    ( Q0 K, N3 g! _% _/ j1 o. ~
20.         block.PrevBlockHash," z( \9 o8 l- L" m) p
    
21.         Int2Byte(block.TimeStamp),
    " J; W2 v8 F) g& }
22.         block.MerkeRoot,9 H# [0 z9 [- D; K; |9 u
    
23.         Int2Byte(nonce),9 V3 D" o0 A0 `" K: a9 ~4 |( d: [
    
24.         Int2Byte(targetBits),; T' n. R. B5 r
    
25.         block.Data}7 z; V4 ?' @0 E. ^# z6 P' V8 \1 @
    
26.     data := bytes.Join(tmp, []byte{})    return data
    ) D: a( u: `7 u7 a' L2 c; G
27. }func (pow *ProofOfWork)Run() (int64, []byte) {    var nonce int64
    6 O+ O( `6 \+ k% J3 B
28.     var hash [32]byte
    : p# i# r; V6 Q& \7 f: q
29.     var HashInt big.Int7 t' J& P0 }" v# P/ t& i
    
30.     fmt.Printf("target hash:", pow.targetBit.Bytes())    for nonce ! V0 x( N* }: z$ w
    
31. python版
    5 ~3 ^- U9 y) {7 {. g3 ^1 E$ m
32. function isValidHashDifficulty(hash, difficulty) {  for (var i = 0, b = hash.length; i = difficulty;
    * N( [- J3 F, T: A7 h1 t
33. }import hashlib"""
    5 w# a) E* S5 L7 f3 ^5 r
34. 工作量证明
      M6 p1 |  f2 K4 y4 I
35. """class ProofofWork():
    0 M# v' W! ^$ Z* u6 M
36.     """
    5 `6 e6 @  R% g+ _) b8 Q& \
37.     pow. B5 j8 W# g8 X- s6 N' h
    
38.     """
    5 w* N6 g+ m; ?! R4 t7 x
39.     def __init__(self, block):) b0 `. L' b6 Y0 E! N
    
40.         self.block = block    def mine(self):
    , a$ g& n. Y* N" |
41.         """
    8 |$ q$ K; Y3 m8 r
42.         挖矿函数
    $ J: e0 L0 |+ h7 X* @
43.         :return:* F1 {7 l' A8 Q0 u# ]
    
44.         """
    : n0 |+ f' [+ i3 H  j$ c
45.         i = 0
    ! L7 o4 A: i; r( A
46.         prefix = '0000'8 p; S* D* t& [% ~! u  X4 c
    
47.         while True:
    / G: X* |  ^  O, o
48.             nonce = str(i)3 Y( b# G% A! L
    
49.             message = hashlib.sha256()
    + i$ N( l5 x. ?/ ]
50.             message.update(str(self.block.data).encode('utf-8'))% ~9 w  C' j: }  q- \* ^* T
    
51.             message.update(nonce.encode("utf-8"))  j( r9 A$ k* S. X$ C
    
52.             digest = message.hexdigest()            if digest.startswith(prefix):                return nonce, digest9 i- K$ U& Z$ G. ?4 h
    
53.             i += 1) V2 g5 {/ Z) R) o+ e$ M  ~1 c
    

复制代码