用 Python 从零开始创建区块链

我们都对比特币的崛起感到惊讶惊奇，并且想知道其背后的技术——区块链是如何实现的。
但是完全搞懂区块链并非易事，至少对我来讲是这样。我喜欢在实践中学习，通过写代码来学习技术会掌握得更牢固。通过构建一个区块链可以加深对区块链的理解。
准备工作
我们知道区块链是由区块的记录构成的不可变、有序的链结构，记录可以是交易、文件或任何你想要的数据，重要的是它们是通过哈希值（hashes）链接起来的。
如果你不知道哈希值是什么，这里有一个解释。
这份指南的目标人群：阅读这篇文章，要求读者对Python有基本的了解，能编写基本的Python代码，并且需要对HTTP请求有基本的理解。
环境准备：确保已经安装Python3.6+,pip,Flask,requests。安装方法：
pipinstallFlask==0.12.2requests==2.18.4
同时还需要一个HTTP客户端，比如Postman，cURL或其它客户端。
一、开始创建BlockChain
打开你最喜欢的文本编辑器或者IDE，比如PyCharm，新建一个文件blockchain.py，本文所有的代码都写在这一个文件中。如果你丢了它，你总是可以引用源代码。
BlockChain类
首先创建一个Blockchain类，在构造函数中创建了两个列表，一个用于储存区块链，一个用于储存交易。
以下是BlockChain类的框架：

classBlockchain(object):8 U a. R" V/ S' o- S4 F
def__init__(self):
0 x, W8 g) x/ A9 ~
self.chain=[]9 S, \8 c' i' D; X5 |7 o% J1 `# F
self.current_transactions=[]
, p1 K4 P0 S0 V/ M6 K
defnew_block(self):
& U: o' F. b8 s% z& E) s0 {( O i
#CreatesanewBlockandaddsittothechain
# J7 j% ~0 Q2 R& x2 e5 o
pass
$ S6 j: _' @) S r, N. `! h
defnew_transaction(self):9 C( H$ g/ u6 I. T
#Addsanewtransactiontothelistoftransactions
" W. u- i6 }& r# o1 S2 Q4 }7 ~
pass
5 |# p3 ]6 ?5 ]/ k4 g, p' B
@staticmethod
, m: k1 @7 ~5 b! ?! P; ^
defhash(block):" D P F+ d. }! X$ D
#HashesaBlock
0 r) [7 N% |- |2 O1 R
pass6 M; @3 Y1 @. C8 ^6 H. Z
@property! \" N) u3 m( Y
deflast_block(self):
& N7 k5 e" K; m/ ?. ^4 Q- H
#ReturnsthelastBlockinthechain' T% W6 B- r$ A) C `0 }
pass

复制代码

-我们的区块链类的蓝图-
Blockchain类用来管理链条，它能存储交易，加入新块等，下面我们来进一步完善这些方法。
块结构
每个区块包含属性：索引（index），Unix时间戳（timestamp），交易列表（transactions），工作量证明（稍后解释）以及前一个区块的Hash值。
以下是一个区块结构：

block={9 y& K+ Q9 \1 g* ^ u' \; I. q
'index':1,! v, K3 u6 a; u2 j1 A
'timestamp':1506057125.900785,) w2 H) ]0 o$ i
'transactions':[
2 z# I9 H. \2 X7 q2 V
{
* v% |. U0 e" l6 W- K5 u1 K
'sender':"8527147fe1f5426f9dd545de4b27ee00",
0 P; Y' Z) `; k
'recipient':"a77f5cdfa2934df3954a5c7c7da5df1f",9 S( f" a/ `2 F3 c
'amount':5,
h9 P4 @1 w, f
}
: H) g5 X) Z% j$ Z* `! Y! P, Y
],$ F* e4 c. T+ X! Z: D& i
'proof':324984774000,2 v4 q* |- _- D8 [
'previous_hash':"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
/ F* P' s2 X. E% m) n
}

复制代码

-链上一个区块的例子-
到这里，区块链的概念就清楚了，每个新的区块都包含上一个区块的Hash，这是关键的一点，它保障了区块链不可变性。如果攻击者破坏了前面的某个区块，那么后面所有区块的Hash都会变得不正确。
确定这有用吗？嗯，你可以花点彻底了解它——这可是区块链背后的核心理念。
加入交易
接下来我们需要添加一个交易，来完善下new_transaction()方法。

classBlockchain(object):
( p, s7 ~5 a4 p H# P( w: l
...
1 n/ O: ?+ o+ ?1 x1 p
defnew_transaction(self,sender,recipient,amount):0 ]. u# o% e1 ?1 D. ^- m! p( j
"""3 k3 T% y+ q i- F
生成新交易信息，信息将加入到下一个待挖的区块中; S& g3 F9 k. O- M+ p3 e
:paramsender:AddressoftheSender
6 ^# e( v: x' c+ A
:paramrecipient:AddressoftheRecipient1 J& a7 O) i: S& }- b
:paramamount:Amount) H2 A5 d( t7 |2 H
:return:TheindexoftheBlockthatwillholdthistransaction3 b! j9 W: l9 _
"""4 g/ a2 w# m- T7 G& O. I
self.current_transactions.append({
- S0 j( K. h. ?: v8 }; P3 l* F
'sender':sender,
' c$ f; F2 g9 H8 ?3 m6 f( [
'recipient':recipient,
% C' }, ]$ |% q u9 u4 O3 W
'amount':amount,5 \* g' d9 B( F
})7 c* _! T8 `. w$ m& ^7 y0 l. A+ i
returnself.last_block['index']+1

复制代码

new_transaction()方法向列表中添加一个交易记录，并返回该记录将被添加到的区块（下一个待挖掘的区块）的索引，等下在用户提交交易时会有用。
创建区块
当Blockchain实例化后，我们需要构造一个创世块（没有前区块的第一个区块），并且给它加上一个“工作量证明”。
每个区块都需要经过工作量证明，俗称挖矿，稍后会继续讲解。
为了构造创世块，我们还需要完善new_block()、new_transaction()和hash()方法：

importhashlib8 v) A% C% d3 f7 @
importjson* }: F" Z+ ]& J, _' Q1 |( i
fromtimeimporttime1 h( c$ Q8 G7 e v( V
classBlockchain(object):- a2 ~7 {; T0 L5 D% _
def__init__(self):
, M. u5 U, A: k; A1 x
self.current_transactions=[]7 J8 \5 [# X! |
self.chain=[]
6 k/ |' i6 C' n3 a( n3 C
#Createthegenesisblock
+ [6 S' Q, B1 t& I9 Q
self.new_block(previous_hash=1,proof=100)
: p [ }# C- j4 g# V
defnew_block(self,proof,previous_hash=None):% {4 M, @! j7 K4 [5 N. K
"""1 H1 N* V$ o+ z7 g$ D; r
生成新块- G5 v, e! i- J2 T
:paramproof:TheproofgivenbytheProofofWorkalgorithm
& V6 V8 G3 ?. _0 f1 n0 ~
:paramprevious_hash:(Optional)HashofpreviousBlock
& @6 O$ n) B% t$ C* t7 Z) m
:return:NewBlock/ x% E, I- l( k2 _+ r* P
"""
' h* Y, A5 @) C" {+ ~# o6 [
block={
F9 Q5 m, w1 A( @: O7 I# x
'index':len(self.chain)+1,4 e" Q4 |1 ]3 _: s3 P& J+ W
'timestamp':time(),: [( F5 B# z1 A- {" J
'transactions':self.current_transactions,- }3 e8 a" d% T4 K
'proof':proof,6 _! u0 M! f; B! j7 e3 `* I
'previous_hash':previous_hashorself.hash(self.chain[-1]),
+ } q/ T9 t: i1 I
}
1 |" O4 W+ \) Q; \& N
#Resetthecurrentlistoftransactions6 U+ o6 n7 N y( Y. _
self.current_transactions=[]$ f9 B0 a: `7 Y, p" V
self.chain.append(block)
' |$ s1 a" O- d3 M5 m/ r- `
returnblock. m! v# P! L3 ^* d- x
defnew_transaction(self,sender,recipient,amount):
2 G, V" }% d% p4 l
"""
/ u0 w# {9 F& O( _1 [/ m
生成新的交易信息，信息将加入到下一个待挖的区块中4 N. {1 T, F- S6 T+ l- t$ \2 P
:paramsender:AddressoftheSender7 q; O- u- _- _$ u/ R; X+ P$ [& ]
:paramrecipient:AddressoftheRecipient7 H7 e, }) [ X
:paramamount:Amount5 O/ p3 {6 [* x g
:return:TheindexoftheBlockthatwillholdthistransaction
, Y1 A4 F* k9 ^2 J
"""
* K0 H7 d h, m5 r5 ?: ?
self.current_transactions.append({
; o, i% g% B# u q. m) H6 [# r; ]
'sender':sender,
% N/ B5 @) O9 l1 j( f
'recipient':recipient,
: F% i6 }% g, L' U/ a& Y
'amount':amount,+ \) m6 J& I/ y! a* g$ R0 f1 v9 b: q
})
' n/ S6 n- ^5 F7 H; K. @
returnself.last_block['index']+1
( y" N) @5 e; I$ J" ] {% r
@property0 z! @, s* T4 M$ G1 v# u/ s7 W" _" ?
deflast_block(self):2 n3 e* ^/ t* l; v
returnself.chain[-1]
/ h* f3 r% ?7 H$ X
@staticmethod5 ]% o4 P! Q& u U/ k* s
defhash(block):" m; j) S0 _5 D5 @1 @
"""
3 _( y( d6 Q7 c/ i
生成块的SHA-256hash值
3 n _+ [. {. j1 G t
:paramblock:Block. A3 @& V/ s4 L" o6 b4 G r
:return:
# `. f H: d f3 B" B8 N9 o
"""

复制代码

#WemustmakesurethattheDictionaryisOrdered,orwe'llhaveinconsistenthashes
block_string=json.dumps(block,sort_keys=True).encode()
returnhashlib.sha256(block_string).hexdigest()
上述应该是非常直接的——我已经添加了一些注释和字符来帮助大家理解。当表达出我们的区块链时，我们也快要完成了。但现在，你肯定在疑惑新区块是如何被创建、伪造或是挖出的。
理解工作量证明
新的区块依赖工作量证明算法（PoW）来构造。PoW的目标是找出一个符合特定条件的数字，这个数字很难计算出来，但容易验证。这就是工作量证明的核心思想。
为了方便理解，我们举个例子：
假设一个整数x乘以另一个整数y的积的Hash值必须以0结尾，即hash(x*y)=ac23dc…0。设变量x=5，求y的值？用Python实现如下：

fromhashlibimportsha256
7 ~8 \! W$ R# W) s
x=5! I( K5 d0 U" Q+ k
y=0#y未知6 o, f3 }& G, C* x8 ]
whilesha256(f'{x*y}'.encode()).hexdigest()[-1]!="0":4 `+ w1 r3 c i% G9 |" n$ N- f
y+=1
: T) n, u. U# D
print(f'Thesolutionisy={y}')

复制代码

结果y=21，因为：
hash(5*21)=1253e9373e...5e3600155e860
在比特币中，使用称为Hashcash的工作量证明算法，它和上面的问题很类似。矿工们为了争夺创建区块的权利而争相计算结果。通常，计算难度与目标字符串需要满足的特定字符的数量成正比，矿工算出结果后，会获得比特币奖励。
当然，在网络上非常容易验证这个结果。
实现工作量证明
让我们来实现一个相似PoW算法，规则是：
寻找一个数p，使得它与前一个区块的proof拼接成的字符串的Hash值以4个零开头。

importhashlib- G9 Q9 q% e+ v+ R, ^
importjson
0 `1 ?6 v8 G* S/ ]7 N1 O7 \& r' W
fromtimeimporttime
8 }" n( z" f% s) i
fromuuidimportuuid49 h6 S8 ]8 F6 D: U: r+ A
classBlockchain(object):
- [1 l* C- Y! W, l
...
# Q; j% G4 c9 n5 Q1 V! s6 V4 s
defproof_of_work(self,last_proof):
) c# _! l" P& M& F8 B
"""! }0 _# @# q, o7 Q; r, t
简单的工作量证明:" R T) M+ R* }$ P
-查找一个p'使得hash(pp')以4个0开头
5 e' F7 K- c, x- U! Z2 t
-p是上一个块的证明,p'是当前的证明
& h7 ?0 _5 Y; [ i
:paramlast_proof:
! p4 Y* `) k g" u- N% a5 ^
:return:. G4 n! P# T: I D3 a `
"""# X- p; y. k2 y6 [5 N; h1 T( S4 s
proof=05 q# U: A5 [7 ^+ x7 _8 i
whileself.valid_proof(last_proof,proof)isFalse:+ |5 V1 @5 O2 c2 {# O6 `$ V
proof+=1$ y/ q. b7 }4 C8 m
returnproof/ L) h6 K0 Q8 z
@staticmethod
* v G! m6 M" [0 Z- b
defvalid_proof(last_proof,proof):
; y+ T+ q! e' |$ H% D" c/ w: A( e- S
"""! Z. G4 J6 X1 W. L
验证证明:是否hash(last_proof,proof)以4个0开头?( N5 n2 n2 H) w/ n
:paramlast_proof:PreviousProof! g }* l3 ], p! N
:paramproof:CurrentProof4 b1 D$ g- z% G- a6 k* |
:return:Trueifcorrect,Falseifnot.
6 ]! O z2 \! K! T
"""
: \+ _# _3 D' v* d! h1 W
guess=f'{last_proof}{proof}'.encode()
) \. I; e! V6 [
guess_hash=hashlib.sha256(guess).hexdigest()
7 F" V, a8 \0 U6 F( s
returnguess_hash[:4]=="0000"
5 }0 U# u, S- N1 V
```

复制代码

衡量算法复杂度的办法是修改零开头的个数。使用4个来用于演示，你会发现多一个零都会大大增加计算出结果所需的时间。
现在Blockchain类基本已经完成了，接下来使用HTTPrequests来进行交互。
##二、BlockChain作为API接口
我们将使用PythonFlask框架，这是一个轻量Web应用框架，它方便将网络请求映射到Python函数，现在我们来让Blockchain运行在基于Flaskweb上。
我们将创建三个接口：

```/transactions/new```创建一个交易并添加到区块: m! H* g5 W& ], y0 {$ o
```/mine```告诉服务器去挖掘新的区块
# ^3 u3 M. t5 ~ v% H8 G: _
```/chain```返回整个区块链
4 o- X0 R/ ~2 r7 g L5 s! m3 h: R
###创建节点
5 d9 [7 Z$ p3 }, V" q! ~, K
我们的Flask服务器将扮演区块链网络中的一个节点。我们先添加一些框架代码：
/ }9 S$ T( ]3 N
importhashlib
3 x5 v6 A% H* k* c: T( B% T
importjson
, m) r# Q, a1 A8 P$ o7 n# C
fromtextwrapimportdedent7 m. {) F, x5 k$ c6 E6 [
fromtimeimporttime0 o E; f+ l* Z2 l' ]' H( X
fromuuidimportuuid4
X+ Z, y; x5 g1 I
fromflaskimportFlask
2 O/ l! l+ l9 v+ Q
classBlockchain(object):
9 E: R7 Y- Y" I$ Y
…8 t% g$ h$ m' Q5 j# f# J$ X9 U7 }
InstantiateourNode, a% [$ C, o* O, ]0 s
app=Flask(name)8 X; J" X$ K/ P. @& D4 W
Generateagloballyuniqueaddressforthisnode
' | d3 i: Z* |. H
node_identifier=str(uuid4()).replace(’-’,‘’) d& W, s O% j" e) q+ M* ~
InstantiatetheBlockchain8 o) Q& E+ T8 V, M2 ]
blockchain=Blockchain()
, u* |( @' L: ]" q
@app.route(’/mine’,methods=[‘GET’])
, ?' l5 i6 o6 {& H0 @
defmine():
' E m! B- q' h$ v9 \" k
return“We’llmineanewBlock”
! x8 D/ S- s2 a6 r: N# T
@app.route(’/transactions/new’,methods=[‘POST’])
% ^' Z! z$ K# m U# H& r
defnew_transaction():
6 S2 ^* P( B3 n1 `. n& q3 O
return“We’lladdanewtransaction”7 X5 |# O4 @- n) c9 d) L9 p9 i) @ n
@app.route(’/chain’,methods=[‘GET’])
7 D- _5 b; T @; g
deffull_chain():. n; {! e; K+ t) A% X2 F+ \
response={
# N, p5 B8 P p" g
‘chain’:blockchain.chain,3 L; D8 R$ j/ E. z1 v0 w
‘length’:len(blockchain.chain), W% m8 i3 q( {/ }
}5 m, K9 F- ~2 g5 g, O' o/ U
returnjsonify(response),200% D. k* ~, E1 s) ?; T# ^+ x, X: A. t
ifname==‘main’:
6 |- x9 R$ e5 l* P6 v% c) r7 E- |
app.run(host=‘0.0.0.0’,port=5000)
/ D5 x5 M3 n4 ~5 _
```) R% N/ ]& [% V+ e/ B/ s
简单的说明一下以上代码：
4 a! X* E7 G# Q
第15行：创建一个节点。在这里阅读更多关于Flask的东西。8 y, B$ u+ v; ~
第18行：为节点创建一个随机的名字。& G, E9 s: B }# V, o, j5 {: k3 y
第21行：实例Blockchain类。
# i9 q* e$ h) C& u; P
第24–26行：创建/mineGET接口。
" h7 u4 o% x1 X# w
第28–30行：创建/transactions/newPOST接口,可以给接口发送交易数据。
# h' y* x& r2 X! I
第32–38行：创建/chain接口,返回整个区块链。
$ f+ b8 D9 V; s O) Z% N
第40–41行：服务运行在端口5000上。# J) i8 l5 C" \* J! H
发送交易2 l Y/ g. E! V5 L4 N
发送到节点的交易数据结构如下：
! |) B% }1 O8 F9 @* C- g' ]$ N
{4 ]7 R2 g5 e {. `8 A1 B* H
"sender":"myaddress",
S2 o- z. M2 @5 T- ~* h- w: l( m
"recipient":"someoneelse'saddress",
& R( `' v! o$ ]- \5 Y: \" n
"amount":5
4 r# q+ [' W# A- N. I1 G3 p. h
}
E6 ~# k0 O. G# ?, @1 s8 y
之前已经有添加交易的方法，基于接口来添加交易就很简单了:* J" q( m0 m5 j$ A4 p
importhashlib
d% Y" _8 y8 c( b; ^$ l8 C; P. ?, \
importjson$ t$ a) [( b6 r, E
fromtextwrapimportdedent7 `$ v+ E) q: H
fromtimeimporttime" i2 |; z# ]+ D- ]( x
fromuuidimportuuid43 c1 F1 E0 j% L+ ]8 F8 }, Z4 P5 ]
fromflaskimportFlask,jsonify,request
4 e# J( Y- D! b8 B! r) @
...3 M7 v# l5 w6 T( m0 x
@app.route('/transactions/new',methods=['POST'])
+ l/ @& B" Z. l' ~ S
defnew_transaction():
, P( X" G8 U8 U) D7 L' X- S+ x/ L
values=request.get_json()
$ L& ~/ q% O4 k+ k+ L
#CheckthattherequiredfieldsareinthePOST'eddata
5 l' b( N% q3 N4 ^& ~3 P! |" Q
required=['sender','recipient','amount']0 [0 `3 j4 P3 j6 ]; U* `3 v
ifnotall(kinvaluesforkinrequired):
% W" i6 a$ G ^
return'Missingvalues',400
- G6 z3 c) i7 m8 e4 w
#CreateanewTransaction
- B2 ^/ ?. a& R1 X- a- K5 g% l
index=blockchain.new_transaction(values['sender'],values['recipient'],values['amount'])
, F$ ]* M# P5 w( E0 W
response={'message':f'TransactionwillbeaddedtoBlock{index}'}& l3 E' x* o0 O3 V% @; H! V( z: I
returnjsonify(response),2011 g) V9 `/ t4 @: C/ h) y, u
```
% p# g1 W0 X9 {% y5 ~
-创建交易的方法-0 C3 q3 o9 c$ U2 ~
###挖矿
/ ^/ _- e& ?, M0 d% [( ?
挖矿正是神奇所在，它很简单，做了一下三件事：
# }6 W! C, l8 j
计算工作量证明PoW
X, c6 K7 a( A" F% }
通过新增一个交易授予矿工（自己）一个币" g8 A$ a) t. G [9 w1 t
构造新区块并将其添加到链中
6 d+ j( \. `: \% }
importhashlib H7 E% o8 I$ j( Q9 h
importjson
) J8 R/ @- F# V6 Q
fromtimeimporttime# i( |7 S, ^( l& R2 A
fromuuidimportuuid4* I6 A1 T3 I' G! s/ @# ?0 l/ j
fromflaskimportFlask,jsonify,request' ]7 g9 H; Q4 N* ]! @/ d( N3 Z
…1 o; @' ?' m3 c9 A# F5 A$ q( L/ [
@app.route(’/mine’,methods=[‘GET’])! g- b1 d X! x& L
defmine():
" O& B5 U. R _# A
#Weruntheproofofworkalgorithmtogetthenextproof…
* m3 r4 K2 r: A" R& W
last_block=blockchain.last_block
; A/ q) _# {% q& M' v, D: N/ i r
last_proof=last_block[‘proof’]4 n2 |2 R6 I! ^2 ~( |2 t+ n
proof=blockchain.proof_of_work(last_proof)- @4 l$ M& |% Z1 A
#给工作量证明的节点提供奖励.1 O; B9 ]# {9 |' D
#发送者为"0"表明是新挖出的币.
, A& g1 L2 K2 L: A/ A
blockchain.new_transaction(7 Z- G0 T1 ~3 f# q! K
sender="0",$ A! @ U/ z7 ~/ k( F
recipient=node_identifier,) G' V# y9 r1 X/ S f
amount=1,2 z; U. K, w3 v0 ?
)6 u* H* }$ L' H2 S4 ~
#ForgethenewBlockbyaddingittothechain
8 K1 \0 b- h; S+ e8 m
previous_hash=blockchain.hash(last_block)
1 A. j8 _1 o- _" s9 c) z# t
block=blockchain.new_block(proof,previous_hash)
/ }2 J& t6 M% y& B0 e
response={
# N% \! M: L5 I: } Z
'message':"NewBlockForged",
5 @2 j9 }1 G9 b, d; U( H
'index':block['index'],
4 o& t, _7 h& L1 @- L
'transactions':block['transactions'],5 {2 o2 G$ @/ P
'proof':block['proof'],
3 I1 i1 W' b0 f8 W
'previous_hash':block['previous_hash']," O8 p! ]5 b7 p5 d% m" c
}% E: x8 _5 M9 {" P$ R
returnjsonify(response),200, {3 v9 R' Q' x) H! }
```

复制代码

注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕Blockchain类方法进行交互。到此，我们的区块链就算完成了，我们来实际运行下。
三、运行区块链
你可以使用cURL或Postman去和API进行交互
启动server：
$pythonblockchain.py
*Runningonhttp://127.0.0.1:5000/(PressCTRL+Ctoquit)
让我们通过发送GET请求到http://localhost:5000/mine来进行挖矿：
-使用Postman以创建一个GET请求-
通过发送POST请求到http://localhost:5000/transactions/new，添加一个新交易:
-使用Postman以创建一个POST请求-
如果不是使用Postman，则用一下的cURL语句也是一样的：
$curl-XPOST-H"Content-Type:application/json"-d'{
"sender":"d4ee26eee15148ee92c6cd394edd974e",
"recipient":"someone-other-address",
"amount":5
}'"http://localhost:5000/transactions/new"
在挖了两次矿之后，就有3个块了，通过请求http://localhost:5000/chain可以得到所有的块信息：

{
2 x B5 E7 a U {
"chain":[
0 `2 l8 K( \2 Z
{7 M4 e: J2 `2 F: ~- f
"index":1,
+ P; X% Y0 o3 e: U/ B2 [) W
"previous_hash":1,
% F; ?' k2 N9 y
"proof":100,
# _5 V; ^1 D8 H$ i
"timestamp":1506280650.770839,
) m! J, ?% H# p: i& J, ?
"transactions":[]
! @: v4 b5 r# Z* o& D
},4 Y4 g; V. V9 E/ w
{% n, q- E, O8 `6 U+ U
"index":2,
- H' |6 \4 h. T. i' a, c: O
"previous_hash":"c099bc...bfb7",, }9 s' `4 A, b$ r/ B. L5 B
"proof":35293,- T9 v" k+ x+ O" j4 S4 c
"timestamp":1506280664.717925,* p. p8 D. a4 @& h% @ ^
"transactions":[
# o3 @; M, ~8 O: F
{
6 \4 V3 {7 d- w( L5 M
"amount":1,
% W5 t ^& V: |* s4 i ]3 i
"recipient":"8bbcb347e0634905b0cac7955bae152b",
" r- @' z% W. a1 n6 s8 H/ f
"sender":"0"/ Y/ `2 @- Z( Y# C$ K" D/ n
}
' i3 ^; @' R8 n' c% P
]2 s" e3 V8 Y# b6 ?0 }- b
},& N( b7 N( \- T5 w
{
( _/ A( ?- \4 i2 D
"index":3,8 a3 W% i7 ~ n ]/ b4 P& \4 {
"previous_hash":"eff91a...10f2",
0 ~. Y8 H# O6 J' U p/ r
"proof":35089,
- I$ O# V; c$ l. q! X0 `
"timestamp":1506280666.1086972,3 N; C. j7 \& o
"transactions":[0 k$ Y/ f/ ~" `9 @2 R& x( h F" R" G
{
( t$ Q* l# k2 k6 p3 B
"amount":1,
! C; H3 T8 ?. M' X
"recipient":"8bbcb347e0634905b0cac7955bae152b",
, P" l3 @3 J; V$ l( i% r% c( E
"sender":"0"
& v- W3 B6 ^7 ]- K$ n
}
! J% a+ N2 [( N8 c4 d* U' U
]
: e! ^7 W; ?) U$ l: B" y2 g
}
# A/ J! z9 f! O! B0 \5 m
],
0 R6 ^7 M% X# b* Y7 `; q$ \( F
"length":3% F% u9 {# g* d* \9 r* y
}

复制代码

四、一致性（共识）
非常棒，我们已经有了一个基本的区块链可以接受交易和挖矿。但是区块链系统应该是分布式的。既然是分布式的，那么我们究竟拿什么保证所有节点有同样的链呢？这就是一致性问题，我们要想在网络上有多个节点，就必须实现一个一致性的算法。
注册节点
在实现一致性算法之前，我们需要找到一种方式让一个节点知道它相邻的节点。每个节点都需要保存一份包含网络中其它节点的记录。因此让我们新增几个接口：
/nodes/register接收URL形式的新节点列表
/nodes/resolve执行一致性算法，解决任何冲突，确保节点拥有正确的链
我们修改下Blockchain的init函数并提供一个注册节点方法：

...
5 p2 q( Q# u& Q1 X/ ]
fromurllib.parseimporturlparse
4 S, l" W; G; C
...
( J7 ~* m1 n c2 p
classBlockchain(object):8 h8 X9 j' O8 g* u7 P. E5 w
def__init__(self):
- ?% u. ^, D; c, X d j( ^
...
+ L N) N0 U3 [7 l
self.nodes=set()% Q: Q, @ \5 j. e* {( D) M2 N, f
...! M$ C: A3 M- j \4 g' X
defregister_node(self,address):) y* E* b; f9 X' s1 ^
"""
, V9 s* x% ^" i; e" N$ r/ V
Addanewnodetothelistofnodes
o; }$ L1 p" x; ~/ ?* b$ }% ?# h
:paramaddress:Addressofnode.Eg.'http://192.168.0.5:5000'
7 b+ ?' \3 \ J9 |' W8 o! P1 b
:return:None
5 Q! J7 }, C3 K; _2 M* F
"""0 L. @0 U2 ^ @& F3 |
parsed_url=urlparse(address). O( ?1 D) i0 V9 Q* O) ^
self.nodes.add(parsed_url.netloc): t& h) ~# M4 L' e% c
```
4 b! Z# L, w+ w: [2 e! B
我们用set()来储存节点，这是一种避免重复添加节点的简单方法——这意味着无论我们添加特定节点多少次，它实际上都只添加了一次。
. R% l" O6 l. ~+ Q3 j( b
###实现共识算法
9 h. c' F! p6 `7 O
前面提到，冲突是指不同的节点拥有不同的链，为了解决这个问题，规定最长的、有效的链才是最终的链，换句话说，网络中有效最长链才是实际的链。我们使用以下的算法，来达到网络中的共识。, m9 e, C& H! A( P3 Q$ S
…0 ]- i6 g& ]4 M2 l! \3 k
importrequests
8 A$ j0 g V3 G3 f, n H
classBlockchain(object)
3 {: f7 j1 i2 [4 ~3 @# f
…! r, H. J& i0 F' M
defvalid_chain(self,chain):4 O4 g0 I3 n* S, ]$ p/ [
"""
4 Q7 }7 G8 ]0 x5 [5 j
Determineifagivenblockchainisvalid
: \0 f. z1 I* E! |4 {6 w
:paramchain:Ablockchain
6 K$ Z6 \7 c* H' W+ s
:return:Trueifvalid,Falseifnot
5 Y3 c2 Z& U& N: H! Z
"""; ~- ?4 }0 z! k6 B' p" F
last_block=chain[0]7 }$ b2 n6 h+ h+ C& Q
current_index=1- T7 ^; c' t; B4 O
whilecurrent_indexmax_lengthandself.valid_chain(chain):
, x( O/ h: L0 x5 _ }2 n2 }+ \
max_length=length
6 J+ W1 c" T4 p4 u0 B+ {
new_chain=chain
8 n; f$ v0 _8 B" M. L
#Replaceourchainifwediscoveredanew,validchainlongerthanours4 k' D+ l ~7 h- S
ifnew_chain:
2 J2 C1 s) o- k- ~ I5 Q
self.chain=new_chain
) F* y4 z3 d9 B0 ]5 k7 t
returnTrue
7 ~6 o3 g' C. l' v' |
returnFalse* B# c( r1 @& x6 Q! O' e8 }0 h4 n5 {
```

复制代码

第1个方法valid_chain()用来检查是否是有效链，遍历每个块验证hash和proof。
第2个方法resolve_conflicts()用来解决冲突，遍历所有的邻居节点，并用上一个方法检查链的有效性，如果发现有效更长链，就替换掉自己的链。
让我们添加两个路由，一个用来注册节点，一个用来解决冲突。

@app.route('/nodes/register',methods=['POST'])
' O U/ e! A4 @# E! q4 W/ ^! M
defregister_nodes():
* h3 b: t4 n% a! c Y# M8 e2 |
values=request.get_json()
+ K/ |; r- w t
nodes=values.get('nodes')
1 g+ L5 t; A" W' z
ifnodesisNone:$ B! H: w4 j! p& c! h: u; D
return"Error:Pleasesupplyavalidlistofnodes",400 _: T9 ~' D4 w: Z$ h6 _1 L. A
fornodeinnodes:+ z0 m! G' ]+ r9 P) s. E
blockchain.register_node(node)
& o2 p* y7 w( S' c* }
response={
/ a6 `+ X8 r/ N2 F( A0 u# s
'message':'Newnodeshavebeenadded',
) q0 k( Y2 A% c5 t2 s
'total_nodes':list(blockchain.nodes),
) i6 ^! p& V# i& F
}) P, z: W$ o# c" ]4 `4 e7 R
returnjsonify(response),201
# T" c# E, T, Y% Q9 M( m# ]* b
@app.route('/nodes/resolve',methods=['GET'])
+ {6 K* a, \5 a9 t) B1 H
defconsensus():
. E! r) Q1 z6 A4 M
replaced=blockchain.resolve_conflicts()
( K' f7 C; B/ s5 O/ }3 _
ifreplaced:: K6 g! x1 G5 s- U
response={9 H1 Z4 ]0 O; _. |
'message':'Ourchainwasreplaced',
6 R4 N( L" J0 [- L
'new_chain':blockchain.chain
7 D/ B2 x" b! j- D
}
. C8 b3 A& G+ y/ V
else:
" l5 b$ ?( \; w+ X
response={
4 o A/ d5 m; ?. N# D, ]
'message':'Ourchainisauthoritative',
. Z1 O: z3 D5 K: y6 p# N4 k
'chain':blockchain.chain+ f( L' k7 {8 R" [7 L8 G8 x! q- i3 }
}# u: Z( C- D# S. o( t- B6 @2 o
returnjsonify(response),200, M1 F. i9 h# E
```

复制代码

你可以在不同的机器运行节点，或在一台机机开启不同的网络端口来模拟多节点的网络，这里在同一台机器开启不同的端口演示，在不同的终端运行一下命令，就启动了两个节点：```http://localhost:5000```和```http://localhost:5001```。

-注册一个新的节点-
然后在节点2上挖两个块，确保是更长的链，然后在节点1上访问GET/nodes/resolve，这时节点1的链会通过共识算法被节点2的链取代。

浏览过的版块