用 Python 从零开始创建区块链 - 区块链技术 - BitMere

我们都对比特币的崛起感到惊讶惊奇，并且想知道其背后的技术——区块链是如何实现的。
但是完全搞懂区块链并非易事，至少对我来讲是这样。我喜欢在实践中学习，通过写代码来学习技术会掌握得更牢固。通过构建一个区块链可以加深对区块链的理解。
准备工作
我们知道区块链是由区块的记录构成的不可变、有序的链结构，记录可以是交易、文件或任何你想要的数据，重要的是它们是通过哈希值（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):
) f# M* u. R$ M1 _4 f# l
def__init__(self):, ~ V5 j/ N, T8 X
self.chain=[]. }0 M/ y- ^+ r7 i, K
self.current_transactions=[]
k' k3 P0 k4 N+ g6 Q
defnew_block(self):
- D# u1 f9 K9 \( ~5 [$ S
#CreatesanewBlockandaddsittothechain. t0 j! P- U# ~2 E/ U9 h
pass. L: b' z$ U* g6 e+ o6 D# K6 O( B
defnew_transaction(self):
Y1 f) ]) h! q& u
#Addsanewtransactiontothelistoftransactions1 }: L+ _9 Q k1 b
pass2 {# G3 g: O% J. [" g. }( {8 U. Z2 ]
@staticmethod
- @4 R4 l2 A* Y, q
defhash(block):
3 S4 W( N) N" H0 }7 n w7 G/ i
#HashesaBlock
# O' U- k; x1 ]# a* g) L
pass4 E ~% ?1 u0 P) b" }( @/ f) U/ b
@property" G9 m. H& i) L# i5 F0 w
deflast_block(self):
" k, Y1 }2 _( H& P+ z+ g
#ReturnsthelastBlockinthechain
7 ^: g9 ?( r9 M% ^) P1 ^2 U
pass

复制代码

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

block={; t n3 R: L1 l; R* q/ Q
'index':1,. \$ S9 B4 u7 G" Y8 u8 v+ X
'timestamp':1506057125.900785,
' K# `. L! ?/ z* q# B
'transactions':[
! E" [7 E2 I# ]
{
& ?0 L% h8 g2 c
'sender':"8527147fe1f5426f9dd545de4b27ee00",
0 i, b. f( D6 _$ l F8 d c
'recipient':"a77f5cdfa2934df3954a5c7c7da5df1f",
# X J" B" g! J8 x+ {0 G, v
'amount':5,9 e6 V4 h: e/ b
}3 {3 W H! U2 t- ?! J
],
6 E8 {: `! O. J0 ?$ v3 d" t/ ?! G: _1 U
'proof':324984774000,5 h7 ?- |- p+ h' H4 a, I
'previous_hash':"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
?- a' Y4 _1 ]5 `; l& ]
}

复制代码

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

classBlockchain(object): ]# T% l. K. R$ {. @" K
...
, N: `6 Y) w J& f. Q+ i" ^: U
defnew_transaction(self,sender,recipient,amount):
7 Q( k/ S8 z( U2 h w
"""1 x0 M8 y2 M7 y6 ?$ C: c( ?4 [
生成新交易信息，信息将加入到下一个待挖的区块中2 H6 A' e0 `9 V' e" v
:paramsender:AddressoftheSender
% e5 {0 @+ t3 Q4 a% l4 a3 r; B
:paramrecipient:AddressoftheRecipient
% h. }! T% m# t2 V
:paramamount:Amount0 K4 d# V3 Q& N7 f( N6 W
:return:TheindexoftheBlockthatwillholdthistransaction; A: d, K" G' I7 b! X4 P0 ~
"""
4 o5 W0 J) ]4 f+ T* R }' d" D
self.current_transactions.append({' e. a% ?/ U" v" t0 w& ^$ A
'sender':sender,
; T$ w8 a E7 Q3 r/ x+ z
'recipient':recipient,
2 {7 X Z4 u8 c% R& |" I8 ?' F
'amount':amount,
9 H& j% Y/ o/ n6 B) V$ `
})3 X. y0 }4 S) C7 w
returnself.last_block['index']+1

复制代码

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

importhashlib
' N5 I" A/ {4 f3 A
importjson0 `5 z o4 X5 l8 f9 M
fromtimeimporttime) P7 k4 V+ K# [
classBlockchain(object):1 w6 X4 H/ @* U) f
def__init__(self):
4 |8 L" u. c5 T" Z3 @, ~' M
self.current_transactions=[]
3 ~; N: ~+ u" \! v
self.chain=[]
0 g% O1 v! W- G$ a
#Createthegenesisblock
: T4 }1 v4 ? n1 H
self.new_block(previous_hash=1,proof=100)
]+ f$ b% u( h+ _
defnew_block(self,proof,previous_hash=None):. A/ ]/ V# l6 S. m) f" T
"""( [5 A" t% ?$ p' h; b
生成新块8 K' j" n: K3 z/ k4 z5 Y$ m7 h
:paramproof:TheproofgivenbytheProofofWorkalgorithm
- s$ y$ z" j& W& r: K1 [! R
:paramprevious_hash:(Optional)HashofpreviousBlock
( a d. l4 r" ?5 a. Y! \! V/ P6 v
:return:NewBlock4 [. L/ u& ~) ]" S
"""/ b" B1 J M, t& i/ N
block={
; n1 U/ m* B2 M) d/ F
'index':len(self.chain)+1,+ @6 Y8 \. N+ L% A S8 n: ^
'timestamp':time(),
, T/ f* N2 q: m* ~: _
'transactions':self.current_transactions,; u/ A$ o8 z) A
'proof':proof,
: f5 Q. P7 p/ L! Y
'previous_hash':previous_hashorself.hash(self.chain[-1]),; T/ `6 S( a5 P
}/ I1 B- H! d2 o
#Resetthecurrentlistoftransactions
4 F5 l) Q0 k7 U- j
self.current_transactions=[]
' F5 w% V# ]4 Z4 D) B
self.chain.append(block)
+ p5 ^" R: R' q% `
returnblock
: T9 l P, m/ G. M% w$ a) g
defnew_transaction(self,sender,recipient,amount):
+ J4 N+ L: A3 @/ A
"""
" N" r- N: X! l7 A2 m7 Y) c$ O
生成新的交易信息，信息将加入到下一个待挖的区块中6 X& [) u- S7 N0 x) c# H6 y
:paramsender:AddressoftheSender2 V9 p6 q5 t$ o$ {% P
:paramrecipient:AddressoftheRecipient, M9 @% h. Z; S5 u4 \
:paramamount:Amount
. u! q8 c. P5 w5 d5 H' N
:return:TheindexoftheBlockthatwillholdthistransaction- [4 D; ^! r p0 Z1 }
"""+ G' J2 J5 N0 G/ K3 G# W( n
self.current_transactions.append({$ T9 V, |3 h! H% I) j6 L( l5 E
'sender':sender,+ R/ P9 \9 ], ^ h/ h
'recipient':recipient,- e1 w- G [& q" t1 n
'amount':amount,
y" z P3 v' m& ?6 C
})
- W3 ?& ~: V6 i+ b, ?
returnself.last_block['index']+1
8 u) ]0 \% t) k- `# Z* R
@property; F6 ` K$ [4 v4 I( u# v, B% ^0 T, \
deflast_block(self):; Q& [" R. |0 v* n% S7 I `- Y: N0 D
returnself.chain[-1]
) S1 Q9 k, X6 f+ d, P
@staticmethod
4 c1 z' V* F' J) ]6 }5 q( b+ I
defhash(block):8 H7 A; Q/ v' F: v5 F7 }9 a4 n
"""
; k+ h, R L' H, p, f
生成块的SHA-256hash值$ N1 ~7 B* \! |0 W" y" ]
:paramblock:Block
& d1 L. L2 H8 u9 u
:return:
; }7 w/ a0 D7 P2 `
"""

复制代码

#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
* d1 U/ Y% I. \1 G1 Y6 y2 ~
x=53 q/ a* J0 O% J) D6 j
y=0#y未知' F8 b8 H: r! ], }% I- C3 U6 `
whilesha256(f'{x*y}'.encode()).hexdigest()[-1]!="0":
( G- S4 q& b$ j3 A6 l
y+=1
/ y, ?- f5 J s
print(f'Thesolutionisy={y}')

复制代码

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

importhashlib5 n0 n% I6 G0 Y7 p5 k. b
importjson
. p! E* O u) d g2 c
fromtimeimporttime
8 Q) i8 _7 N" f& W
fromuuidimportuuid4
5 D2 `5 j8 {3 O5 L- G: ^
classBlockchain(object):/ o& [! u* v T
...0 i5 n1 z* y e$ Y) z' c* ~
defproof_of_work(self,last_proof):: z* i, x8 _9 q" f
"""
, x# F5 }: x* Y/ a! @# c
简单的工作量证明:2 e( E% A) P" H4 L8 G( K
-查找一个p'使得hash(pp')以4个0开头
3 m% }: v& _, d4 B) P6 z
-p是上一个块的证明,p'是当前的证明
3 _+ u0 z& e/ j! |; p( h, C
:paramlast_proof:
, D8 W% p" Y, ~& K3 c2 ?* S3 X9 Q
:return:
! x0 `9 b. B$ i' p1 T) b! b
"""
0 z1 f9 K- B4 ?0 Q; i
proof=0
+ @( J; g( ?8 k: K/ S) Y; i
whileself.valid_proof(last_proof,proof)isFalse:
1 f* [( Q& b [, W4 r5 a+ E+ H- _
proof+=1
) l: n5 l0 ^: X: v, Q& I
returnproof9 G5 g4 @. I. @
@staticmethod
9 m4 m$ w3 i- B- b8 _& \% F4 } q
defvalid_proof(last_proof,proof):. x, y) J D( {7 H( @2 r
"""& F5 V3 h$ p; ~6 E9 t- \9 ^
验证证明:是否hash(last_proof,proof)以4个0开头?
& f+ K3 b; g9 E0 {
:paramlast_proof:PreviousProof
) Q7 @% U& A- n9 p
:paramproof:CurrentProof' D6 |+ X, X' a( t. @! R/ x. m
:return:Trueifcorrect,Falseifnot.! x. Q+ }5 F3 B- F
"""
# ~' `/ [: F/ C7 I* _
guess=f'{last_proof}{proof}'.encode()6 C) E3 p( i8 j& U: t j
guess_hash=hashlib.sha256(guess).hexdigest()
5 I4 c: f7 z1 I+ A2 k% f7 Z( {6 }
returnguess_hash[:4]=="0000"2 r! S% c) p$ Q3 l8 {
```

复制代码

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

```/transactions/new```创建一个交易并添加到区块3 P' W9 N% Q w# R9 b
```/mine```告诉服务器去挖掘新的区块
& x2 B4 P4 p) L% x
```/chain```返回整个区块链
; \; h2 y6 K# m
###创建节点 c: s3 t& ~: p% ~
我们的Flask服务器将扮演区块链网络中的一个节点。我们先添加一些框架代码：: e; ^& O, ^" g/ I: d
importhashlib* i9 F( A" @1 Q$ V
importjson; h u8 Y. d3 g/ R4 _
fromtextwrapimportdedent5 J* o) }6 {' g6 |6 o
fromtimeimporttime
) {* I7 t L8 y" g4 _
fromuuidimportuuid4
* N5 `- X! c3 Y" ~2 R/ F
fromflaskimportFlask( P" q K+ \4 J* R2 v. I* m3 ^
classBlockchain(object):" d% k! o! V2 |+ q! L' D
…3 h* i A4 {7 G) y3 G
InstantiateourNode
5 r* w" b4 h+ w; K$ o$ C* v2 S8 F
app=Flask(name)
. T: X$ [) `, K. `% \9 ^% u
Generateagloballyuniqueaddressforthisnode" N" s1 Z: B4 H4 n' r
node_identifier=str(uuid4()).replace(’-’,‘’)
# @) }. X$ y( Z+ m# q' ~
InstantiatetheBlockchain
8 T3 h! _ M: E1 W0 f8 o* L" z
blockchain=Blockchain(). \' l; D; _7 o# O+ u
@app.route(’/mine’,methods=[‘GET’])+ ], ~ m4 t/ x5 x4 T0 }4 n
defmine():
3 r( {+ N5 Y5 y [
return“We’llmineanewBlock”
' Z8 r1 x {3 K+ ~6 s$ ?
@app.route(’/transactions/new’,methods=[‘POST’])
6 a- o% X6 b8 u; ~6 W- x5 e
defnew_transaction():
1 Z& F# u P* F3 ?
return“We’lladdanewtransaction”
) G0 V3 T4 U" F. B7 W' S9 d2 D
@app.route(’/chain’,methods=[‘GET’])
) N+ X! _: g3 |% D
deffull_chain():
* ]7 c6 u0 i/ v8 X6 T0 B* y% c
response={
$ Y& K& R7 s- ?2 V8 ~
‘chain’:blockchain.chain,$ L. |5 D1 c9 T
‘length’:len(blockchain.chain), ?. Y5 f4 }! P; r d8 e8 x& `
}
2 O& z2 \& P; a5 V( X" O. K
returnjsonify(response),2008 U9 ?! ^/ D' s" W6 d b
ifname==‘main’:$ P/ N: k- ]! O: P2 |3 f' ]
app.run(host=‘0.0.0.0’,port=5000)
/ x1 {8 p1 H7 O- n& {2 f- g
``` X3 ^, y& w8 G: Y8 @( Y" B Q; v+ f5 ~$ E
简单的说明一下以上代码：
$ L& N$ A% |+ U- H/ ]' a
第15行：创建一个节点。在这里阅读更多关于Flask的东西。
" K0 I" g1 R- C6 x
第18行：为节点创建一个随机的名字。
9 S3 w- e I4 j" k3 ^1 D# g0 ~
第21行：实例Blockchain类。* s8 |' T( I; A5 Q% y, r( s+ j" ~
第24–26行：创建/mineGET接口。
0 P0 u+ \2 h1 C' V: a, E/ L) D
第28–30行：创建/transactions/newPOST接口,可以给接口发送交易数据。3 U/ j" c1 ~4 N1 Y$ x# J3 `
第32–38行：创建/chain接口,返回整个区块链。0 ~# x1 f d/ K, q; V# L# k
第40–41行：服务运行在端口5000上。! l w5 J3 j2 i' L4 P
发送交易. U+ X) @# U& Z, |
发送到节点的交易数据结构如下：/ G* M" b: y& |: \5 L
{. l( O" ]- D; Y* ?/ I- I
"sender":"myaddress",
- A7 l- |7 W1 e$ J2 X9 ^' s8 _
"recipient":"someoneelse'saddress",
5 Y3 e! a% [6 O0 p1 i8 Y6 o: A
"amount":5' d6 S9 b: \9 _( q& K0 p+ P
}2 I* E6 s0 G- i1 Z/ m9 j1 p
之前已经有添加交易的方法，基于接口来添加交易就很简单了:
" |: j+ i9 w- {) y' G& t
importhashlib! ]; p7 q: e' n1 w% ~
importjson, |6 J2 A9 U8 p4 t
fromtextwrapimportdedent
# ^7 j- M& V7 _# A9 D, B9 l2 c
fromtimeimporttime
5 r; R: n# a! h* ?; T, x
fromuuidimportuuid4
' `& ?8 L+ S7 b# Y
fromflaskimportFlask,jsonify,request& f* ~4 `$ ~. ]' ^ a
...
- G8 U# ^/ `/ D \
@app.route('/transactions/new',methods=['POST'])
) I D! O [. v3 r) b
defnew_transaction():
S# K7 O+ N3 U z) H
values=request.get_json()
8 I# X! _7 O- D7 F, w
#CheckthattherequiredfieldsareinthePOST'eddata
0 ]; l) e& }( C+ S* E7 A# B3 o
required=['sender','recipient','amount']" v5 i% ~) r' f& V) P4 U
ifnotall(kinvaluesforkinrequired):
Y W; {9 t+ k8 }
return'Missingvalues',4000 G% M R! f8 X/ e3 g+ X' |
#CreateanewTransaction
4 w$ }) U9 j& ?7 E" i
index=blockchain.new_transaction(values['sender'],values['recipient'],values['amount'])
2 ]! X; Z3 G$ [+ [: v
response={'message':f'TransactionwillbeaddedtoBlock{index}'}
3 E, ]6 Y- ^3 O7 U: A
returnjsonify(response),201' I% ?* X) V: F) A8 j3 h3 p! \3 Z
```
4 v" }" m- B( H! s7 A
-创建交易的方法-* W9 }( s6 s) d |* M
###挖矿$ s. X% g$ @( f0 b9 Z! C$ D
挖矿正是神奇所在，它很简单，做了一下三件事：
1 r/ G4 P! ^+ `5 h+ w9 X
计算工作量证明PoW/ ^4 R+ D2 E: M
通过新增一个交易授予矿工（自己）一个币
' p' F. W3 z" f, C7 J: `6 U
构造新区块并将其添加到链中
7 Q e4 i T; n2 a0 [% x
importhashlib
+ l: M$ l0 `! o5 ?( K
importjson) N' y) x2 j+ t8 \; ]
fromtimeimporttime
4 H7 I# b& H$ e! @- V
fromuuidimportuuid4
& e& c# A) P9 b g& h+ h. [6 |
fromflaskimportFlask,jsonify,request
( z' s, N1 H; F- B4 W
…, t2 j; f9 O a" X9 ^( P3 m
@app.route(’/mine’,methods=[‘GET’])
" B ~# \* ~" w; j% y- |1 _( k
defmine():
4 ] J. m c- |, S( W$ F. @
#Weruntheproofofworkalgorithmtogetthenextproof…
" B' _8 C/ a, g" L" P+ d9 I! ^, q
last_block=blockchain.last_block+ F9 o7 H3 M: N7 c0 _
last_proof=last_block[‘proof’]
- ]" L- V7 C+ _4 m0 [
proof=blockchain.proof_of_work(last_proof)5 D' m e7 q' _0 Z
#给工作量证明的节点提供奖励.6 O7 a. y0 j# j9 b8 H! z/ H
#发送者为"0"表明是新挖出的币.3 d2 Q! d, j5 n" [
blockchain.new_transaction(
% o7 ], \! _; O' W
sender="0",0 {4 R0 C4 k; G% Z1 l/ Y" ~
recipient=node_identifier,1 {, B) H# C# e4 ] s* B
amount=1,
! ^( h$ r+ _: n
). |1 H2 w0 [4 \/ c4 s3 i
#ForgethenewBlockbyaddingittothechain
previous_hash=blockchain.hash(last_block)( ^2 Q3 N5 t7 k7 `# S
block=blockchain.new_block(proof,previous_hash)
! r# f5 Q3 T- L5 l2 X' S
response={. V" O- Z# [$ F* O
'message':"NewBlockForged",
# k6 B+ o# h1 V8 P
'index':block['index'],6 r, z2 G8 Q& y5 C# |7 l
'transactions':block['transactions'],
; z2 z r5 z* u6 ~! q$ C- Z
'proof':block['proof'],
1 I( [) A- @; P0 j" F: N# j
'previous_hash':block['previous_hash'],
( E! p: \% L# a# U: I+ y6 M! R
}) j; d0 ~; {9 M2 j* {
returnjsonify(response),200: A0 q: U) K: e, a2 J4 I
```

复制代码

注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕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可以得到所有的块信息：

{
8 ~. P4 k& |) n1 H+ N
"chain":[
- k6 d) E; ~( X& m5 {
{' y0 X7 ~+ j- c% H
"index":1,7 s3 P! U! i, ^( C9 L- n& j
"previous_hash":1,
: m. f$ R7 A7 ~. f( i- W
"proof":100,( T, }6 I, V7 ~- g6 g0 F/ T
"timestamp":1506280650.770839,# A5 W- s: i$ A* X
"transactions":[]
& a. K* n! P9 I% @) S; Y
},
6 f* Y. p% }5 B
{
6 v9 l& ~* [; s6 @- i+ e$ o, q) l
"index":2,3 V8 e5 P; u2 `
"previous_hash":"c099bc...bfb7",
$ `- y8 D9 ^# k
"proof":35293,
6 x) }5 M" e, z6 G
"timestamp":1506280664.717925,+ O- _; z b# r2 J6 R) S7 x4 v
"transactions":[
) K7 g& B/ U: n0 _( }
{
0 M; r0 o! w8 [( U
"amount":1,6 m6 f5 H9 O3 d* y
"recipient":"8bbcb347e0634905b0cac7955bae152b",) P2 f% [1 P+ ?
"sender":"0"
! Z! f* V! O0 z0 F
}
0 E; D) M6 d: ~" {. F
]
P- Y0 Y$ Q. i" ~/ [8 u; X
},
$ j* x. A' ~+ {, N7 W7 p
{
- c1 G. [% v3 w% n* A# A7 }5 \
"index":3,
% [, r+ k/ X% u7 z" ~) |/ ^9 y% x( h
"previous_hash":"eff91a...10f2",
% Q. Q3 }& U# I( b: j1 C
"proof":35089,$ B, Y" X; q+ A5 W" w: M
"timestamp":1506280666.1086972,8 P0 c" ^/ A5 a& i/ i2 L$ p
"transactions":[
3 g" N( G& j+ m+ s
{+ w, Z! z6 {2 r" }. T) d7 f
"amount":1,
+ G- r8 K! f* T9 V" s* R& s
"recipient":"8bbcb347e0634905b0cac7955bae152b",
+ Y# r4 l3 h* V. ~9 w1 L* t6 B
"sender":"0"
1 `0 E. |; H! f8 y9 j! Z
}$ U4 i6 K1 K3 \% @( e N" H
]& I7 }' I( S) i* j3 H& [
}/ W% L; |4 M' U* Q: g
],
% \6 w5 z9 d9 r T
"length":3
+ }. ?# ~. E* Z$ M J. G7 A4 l2 W
}

复制代码

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

...2 O5 A- m* a# M
fromurllib.parseimporturlparse
F, }& _; g+ A
...
0 L1 F5 e: E# J' |7 o
classBlockchain(object):
' L% q$ F3 K" j% s6 H4 u+ G
def__init__(self):
7 F+ \! X. k! h* t, n' Z1 C; m. J
...
/ {5 ^( F) {' t# Y- K4 H5 l- g
self.nodes=set()
$ v- O8 D) h, G* R: s1 W. B. P5 G( v
...
~2 F' c. O# ]* m8 @3 ~' t7 p, C
defregister_node(self,address):0 l1 [& M1 q% y' p
"""' m$ X @ M+ p5 U, t
Addanewnodetothelistofnodes
+ B# O* ^# w" j+ O0 y
:paramaddress:Addressofnode.Eg.'http://192.168.0.5:5000'
3 q, ?, s& C. [+ p
:return:None$ H& u( `' t6 Z8 V1 k( Z0 R
"""
. c- f. R3 j, F* T+ X' c7 j9 O
parsed_url=urlparse(address)
# k4 L( o4 b$ k2 i
self.nodes.add(parsed_url.netloc): a6 w. e5 T. _! T3 k; P
```2 B0 { O/ t" b% {# s! D
我们用set()来储存节点，这是一种避免重复添加节点的简单方法——这意味着无论我们添加特定节点多少次，它实际上都只添加了一次。
8 I; r: n y& n' M; V V7 t$ s
###实现共识算法, v" x# s2 H3 U8 }; x6 k- c
前面提到，冲突是指不同的节点拥有不同的链，为了解决这个问题，规定最长的、有效的链才是最终的链，换句话说，网络中有效最长链才是实际的链。我们使用以下的算法，来达到网络中的共识。
) G1 ~; b* W/ I
…
6 _6 r0 {& | f: F
importrequests- O3 Z7 F5 H- i" P3 Y4 \4 M
classBlockchain(object)
5 F- Q3 V) u" r' P
…6 u5 z1 u9 v) |
defvalid_chain(self,chain):# D V% J$ O5 q2 K' z3 S0 J( _
"""
7 `; H; i. L( ]6 B
Determineifagivenblockchainisvalid( K% J: f4 J( @% R3 E
:paramchain:Ablockchain
" A" m5 z! q' e r
:return:Trueifvalid,Falseifnot, f* X4 R8 @1 V6 F1 _7 k* q' R1 C+ ~
"""
; f: i2 F% ?0 ~& c& m0 ]$ z. p! ^
last_block=chain[0]9 N) h5 s5 K8 s) I$ b
current_index=10 C* A% d( g2 N) ?/ o
whilecurrent_indexmax_lengthandself.valid_chain(chain):
" I4 `* G9 M# D! m9 L! z: x
max_length=length: K2 v! N0 R1 T2 x3 x, W# H' V
new_chain=chain1 H3 l/ \! D) t7 t6 h3 [
#Replaceourchainifwediscoveredanew,validchainlongerthanours2 E5 v8 \ n" a a7 v8 {/ ^
ifnew_chain:& J$ F" ^- K* e5 R. m3 H
self.chain=new_chain7 {8 }* K3 n5 M. X% m1 j* m
returnTrue
a) U+ e% D1 [- p. A* c# r9 s, _& x
returnFalse
: J3 C* c7 F/ ~/ B" [2 p9 l: v
```

复制代码

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

@app.route('/nodes/register',methods=['POST']). Q9 G8 s u- W. w% P1 j: g
defregister_nodes():
" V. Y( P* _. x2 W: p9 ]
values=request.get_json()
6 {9 P9 t" L p7 g& g
nodes=values.get('nodes')3 C3 Z$ k ^* e: q, N
ifnodesisNone:) L0 s. J2 w9 J$ t! w$ j/ n% _0 X
return"Error:Pleasesupplyavalidlistofnodes",400
# i L; W ^6 `5 I
fornodeinnodes:
( A' w, d& R& n! a
blockchain.register_node(node)
' m4 o; P2 f7 ~2 _ L/ B/ v( ]- b
response={; A7 P' r( v8 q! }" w
'message':'Newnodeshavebeenadded'," w+ t# k+ d- [% j) T, T$ j
'total_nodes':list(blockchain.nodes),
( C$ W+ [& a; w2 O$ q+ i! D+ G7 ~
}
2 Z' S" c( d% z5 m2 X
returnjsonify(response),201
6 h4 K9 b" j6 D' c1 T
@app.route('/nodes/resolve',methods=['GET']). }1 H& A& s. t
defconsensus():) F- h7 q9 L' M$ d( g
replaced=blockchain.resolve_conflicts()5 L: _( B' D3 C5 I- k( l" z
ifreplaced:6 I* [/ a7 K9 ~" c' U! q
response={
8 L; B) F5 A7 `" H p* ^: }) V
'message':'Ourchainwasreplaced',
6 [7 J) Q; K+ i$ ]
'new_chain':blockchain.chain/ Q, K; `) h9 C. `3 m, G
}) u3 J |8 o" v$ [. @7 a
else:/ U( A+ d) m6 Q6 s' O% \
response={2 `, c5 ?8 O# x3 f2 c
'message':'Ourchainisauthoritative',: L+ y9 |+ {: ^0 E, T
'chain':blockchain.chain
& j7 @8 m8 \+ h [! }2 I
}$ ]1 H1 ~) f, U" e% ]& Z4 N8 h/ g
returnjsonify(response),200
- s1 i% _" X' O, }" q. Z
```

复制代码

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

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