我们都对比特币的崛起感到惊讶惊奇，并且想知道其背后的技术——区块链是如何实现的。
    但是完全搞懂区块链并非易事，至少对我来讲是这样。我喜欢在实践中学习，通过写代码来学习技术会掌握得更牢固。通过构建一个区块链可以加深对区块链的理解。
    准备工作
    我们知道区块链是由区块的记录构成的不可变、有序的链结构，记录可以是交易、文件或任何你想要的数据，重要的是它们是通过哈希值（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类的框架：
  

1. classBlockchain(object):
   
2.     def__init__(self):
   
3.     self.chain=[]
   
4.     self.current_transactions=[]
   
5.     defnew_block(self):
   
6.     #CreatesanewBlockandaddsittothechain
   
7.     pass
   
8.     defnew_transaction(self):
   
9.     #Addsanewtransactiontothelistoftransactions
   
10.     pass
    
11.     @staticmethod
    
12.     defhash(block):
    
13.     #HashesaBlock
    
14.     pass
    
15.     @property
    
16.     deflast_block(self):
    
17.     #ReturnsthelastBlockinthechain
    
18.     pass

Copy the Code

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

1. block={
   
2.     'index':1,
   
3.     'timestamp':1506057125.900785,
   
4.     'transactions':[
   
5.     {
   
6.     'sender':"8527147fe1f5426f9dd545de4b27ee00",
   
7.     'recipient':"a77f5cdfa2934df3954a5c7c7da5df1f",
   
8.     'amount':5,
   
9.     }
   
10.     ],
    
11.     'proof':324984774000,
    
12.     'previous_hash':"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
    
13.     }

Copy the Code

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

1. classBlockchain(object):
   
2.     ...
   
3.     defnew_transaction(self,sender,recipient,amount):
   
4.     """
   
5.     生成新交易信息，信息将加入到下一个待挖的区块中
   
6.     :paramsender:AddressoftheSender
   
7.     :paramrecipient:AddressoftheRecipient
   
8.     :paramamount:Amount
   
9.     :return:TheindexoftheBlockthatwillholdthistransaction
   
10.     """
    
11.     self.current_transactions.append({
    
12.     'sender':sender,
    
13.     'recipient':recipient,
    
14.     'amount':amount,
    
15.     })
    
16.     returnself.last_block['index']+1

Copy the Code

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

1. importhashlib
   
2.     importjson
   
3.     fromtimeimporttime
   
4.     classBlockchain(object):
   
5.     def__init__(self):
   
6.     self.current_transactions=[]
   
7.     self.chain=[]
   
8.     #Createthegenesisblock
   
9.     self.new_block(previous_hash=1,proof=100)
   
10.     defnew_block(self,proof,previous_hash=None):
    
11.     """
    
12.     生成新块
    
13.     :paramproof:TheproofgivenbytheProofofWorkalgorithm
    
14.     :paramprevious_hash:(Optional)HashofpreviousBlock
    
15.     :return:NewBlock
    
16.     """
    
17.     block={
    
18.     'index':len(self.chain)+1,
    
19.     'timestamp':time(),
    
20.     'transactions':self.current_transactions,
    
21.     'proof':proof,
    
22.     'previous_hash':previous_hashorself.hash(self.chain[-1]),
    
23.     }
    
24.     #Resetthecurrentlistoftransactions
    
25.     self.current_transactions=[]
    
26.     self.chain.append(block)
    
27.     returnblock
    
28.     defnew_transaction(self,sender,recipient,amount):
    
29.     """
    
30.     生成新的交易信息，信息将加入到下一个待挖的区块中
    
31.     :paramsender:AddressoftheSender
    
32.     :paramrecipient:AddressoftheRecipient
    
33.     :paramamount:Amount
    
34.     :return:TheindexoftheBlockthatwillholdthistransaction
    
35.     """
    
36.     self.current_transactions.append({
    
37.     'sender':sender,
    
38.     'recipient':recipient,
    
39.     'amount':amount,
    
40.     })
    
41.     returnself.last_block['index']+1
    
42.     @property
    
43.     deflast_block(self):
    
44.     returnself.chain[-1]
    
45.     @staticmethod
    
46.     defhash(block):
    
47.     """
    
48.     生成块的SHA-256hash值
    
49.     :paramblock:Block
    
50.     :return:
    
51.     """

Copy the Code

    #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实现如下：

1.   fromhashlibimportsha256
   
2.     x=5
   
3.     y=0#y未知
   
4.     whilesha256(f'{x*y}'.encode()).hexdigest()[-1]!="0":
   
5.     y+=1
   
6.     print(f'Thesolutionisy={y}')

Copy the Code

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

1. importhashlib
   
2.     importjson
   
3.     fromtimeimporttime
   
4.     fromuuidimportuuid4
   
5.     classBlockchain(object):
   
6.     ...
   
7.     defproof_of_work(self,last_proof):
   
8.     """
   
9.     简单的工作量证明:
   
10.     -查找一个p'使得hash(pp')以4个0开头
    
11.     -p是上一个块的证明,p'是当前的证明
    
12.     :paramlast_proof:
    
13.     :return:
    
14.     """
    
15.     proof=0
    
16.     whileself.valid_proof(last_proof,proof)isFalse:
    
17.     proof+=1
    
18.     returnproof
    
19.     @staticmethod
    
20.     defvalid_proof(last_proof,proof):
    
21.     """
    
22.     验证证明:是否hash(last_proof,proof)以4个0开头?
    
23.     :paramlast_proof:PreviousProof
    
24.     :paramproof:CurrentProof
    
25.     :return:Trueifcorrect,Falseifnot.
    
26.     """
    
27.     guess=f'{last_proof}{proof}'.encode()
    
28.     guess_hash=hashlib.sha256(guess).hexdigest()
    
29.     returnguess_hash[:4]=="0000"
    
30.     ```

Copy the Code

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

1. ```/transactions/new```创建一个交易并添加到区块
   
2.     ```/mine```告诉服务器去挖掘新的区块
   
3.     ```/chain```返回整个区块链
   
4.     ###创建节点
   
5.     我们的Flask服务器将扮演区块链网络中的一个节点。我们先添加一些框架代码：
   
6.     importhashlib
   
7.     importjson
   
8.     fromtextwrapimportdedent
   
9.     fromtimeimporttime
   
10.     fromuuidimportuuid4
    
11.     fromflaskimportFlask
    
12.     classBlockchain(object):
    
13.     …
    
14.     InstantiateourNode
    
15.     app=Flask(name)
    
16.     Generateagloballyuniqueaddressforthisnode
    
17.     node_identifier=str(uuid4()).replace(’-’,‘’)
    
18.     InstantiatetheBlockchain
    
19.     blockchain=Blockchain()
    
20.     @app.route(’/mine’,methods=[‘GET’])
    
21.     defmine():
    
22.     return“We’llmineanewBlock”
    
23.     @app.route(’/transactions/new’,methods=[‘POST’])
    
24.     defnew_transaction():
    
25.     return“We’lladdanewtransaction”
    
26.     @app.route(’/chain’,methods=[‘GET’])
    
27.     deffull_chain():
    
28.     response={
    
29.     ‘chain’:blockchain.chain,
    
30.     ‘length’:len(blockchain.chain),
    
31.     }
    
32.     returnjsonify(response),200
    
33.     ifname==‘main’:
    
34.     app.run(host=‘0.0.0.0’,port=5000)
    
35.     ```
    
36.     简单的说明一下以上代码：
    
37.     第15行：创建一个节点。在这里阅读更多关于Flask的东西。
    
38.     第18行：为节点创建一个随机的名字。
    
39.     第21行：实例Blockchain类。
    
40.     第24–26行：创建/mineGET接口。
    
41.     第28–30行：创建/transactions/newPOST接口,可以给接口发送交易数据。
    
42.     第32–38行：创建/chain接口,返回整个区块链。
    
43.     第40–41行：服务运行在端口5000上。
    
44.     发送交易
    
45.     发送到节点的交易数据结构如下：
    
46.     {
    
47.     "sender":"myaddress",
    
48.     "recipient":"someoneelse'saddress",
    
49.     "amount":5
    
50.     }
    
51.     之前已经有添加交易的方法，基于接口来添加交易就很简单了:
    
52.     importhashlib
    
53.     importjson
    
54.     fromtextwrapimportdedent
    
55.     fromtimeimporttime
    
56.     fromuuidimportuuid4
    
57.     fromflaskimportFlask,jsonify,request
    
58.     ...
    
59.     @app.route('/transactions/new',methods=['POST'])
    
60.     defnew_transaction():
    
61.     values=request.get_json()
    
62.     #CheckthattherequiredfieldsareinthePOST'eddata
    
63.     required=['sender','recipient','amount']
    
64.     ifnotall(kinvaluesforkinrequired):
    
65.     return'Missingvalues',400
    
66.     #CreateanewTransaction
    
67.     index=blockchain.new_transaction(values['sender'],values['recipient'],values['amount'])
    
68.     response={'message':f'TransactionwillbeaddedtoBlock{index}'}
    
69.     returnjsonify(response),201
    
70.     ```
    
71.     -创建交易的方法-
    
72.     ###挖矿
    
73.     挖矿正是神奇所在，它很简单，做了一下三件事：
    
74.     计算工作量证明PoW
    
75.     通过新增一个交易授予矿工（自己）一个币
    
76.     构造新区块并将其添加到链中
    
77.     importhashlib
    
78.     importjson
    
79.     fromtimeimporttime
    
80.     fromuuidimportuuid4
    
81.     fromflaskimportFlask,jsonify,request
    
82.     …
    
83.     @app.route(’/mine’,methods=[‘GET’])
    
84.     defmine():
    
85.     #Weruntheproofofworkalgorithmtogetthenextproof…
    
86.     last_block=blockchain.last_block
    
87.     last_proof=last_block[‘proof’]
    
88.     proof=blockchain.proof_of_work(last_proof)
    
89.     #给工作量证明的节点提供奖励.
    
90.     #发送者为"0"表明是新挖出的币.
    
91.     blockchain.new_transaction(
    
92.     sender="0",
    
93.     recipient=node_identifier,
    
94.     amount=1,
    
95.     )
    
96.     #ForgethenewBlockbyaddingittothechain
    
97.     previous_hash=blockchain.hash(last_block)
    
98.     block=blockchain.new_block(proof,previous_hash)
    
99.     response={
    
100.     'message':"NewBlockForged",
     
101.     'index':block['index'],
     
102.     'transactions':block['transactions'],
     
103.     'proof':block['proof'],
     
104.     'previous_hash':block['previous_hash'],
     
105.     }
     
106.     returnjsonify(response),200
     
107.     ```

Copy the Code

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

1. {
   
2.     "chain":[
   
3.     {
   
4.     "index":1,
   
5.     "previous_hash":1,
   
6.     "proof":100,
   
7.     "timestamp":1506280650.770839,
   
8.     "transactions":[]
   
9.     },
   
10.     {
    
11.     "index":2,
    
12.     "previous_hash":"c099bc...bfb7",
    
13.     "proof":35293,
    
14.     "timestamp":1506280664.717925,
    
15.     "transactions":[
    
16.     {
    
17.     "amount":1,
    
18.     "recipient":"8bbcb347e0634905b0cac7955bae152b",
    
19.     "sender":"0"
    
20.     }
    
21.     ]
    
22.     },
    
23.     {
    
24.     "index":3,
    
25.     "previous_hash":"eff91a...10f2",
    
26.     "proof":35089,
    
27.     "timestamp":1506280666.1086972,
    
28.     "transactions":[
    
29.     {
    
30.     "amount":1,
    
31.     "recipient":"8bbcb347e0634905b0cac7955bae152b",
    
32.     "sender":"0"
    
33.     }
    
34.     ]
    
35.     }
    
36.     ],
    
37.     "length":3
    
38.     }

Copy the Code

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

1. ...
   
2.     fromurllib.parseimporturlparse
   
3.     ...
   
4.     classBlockchain(object):
   
5.     def__init__(self):
   
6.     ...
   
7.     self.nodes=set()
   
8.     ...
   
9.     defregister_node(self,address):
   
10.     """
    
11.     Addanewnodetothelistofnodes
    
12.     :paramaddress:Addressofnode.Eg.'http://192.168.0.5:5000'
    
13.     :return:None
    
14.     """
    
15.     parsed_url=urlparse(address)
    
16.     self.nodes.add(parsed_url.netloc)
    
17.     ```
    
18.     我们用set()来储存节点，这是一种避免重复添加节点的简单方法——这意味着无论我们添加特定节点多少次，它实际上都只添加了一次。
    
19.     ###实现共识算法
    
20.     前面提到，冲突是指不同的节点拥有不同的链，为了解决这个问题，规定最长的、有效的链才是最终的链，换句话说，网络中有效最长链才是实际的链。我们使用以下的算法，来达到网络中的共识。
    
21.     …
    
22.     importrequests
    
23.     classBlockchain(object)
    
24.     …
    
25.     defvalid_chain(self,chain):
    
26.     """
    
27.     Determineifagivenblockchainisvalid
    
28.     :paramchain:Ablockchain
    
29.     :return:Trueifvalid,Falseifnot
    
30.     """
    
31.     last_block=chain[0]
    
32.     current_index=1
    
33.     whilecurrent_indexmax_lengthandself.valid_chain(chain):
    
34.     max_length=length
    
35.     new_chain=chain
    
36.     #Replaceourchainifwediscoveredanew,validchainlongerthanours
    
37.     ifnew_chain:
    
38.     self.chain=new_chain
    
39.     returnTrue
    
40.     returnFalse
    
41.     ```

Copy the Code

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

1. @app.route('/nodes/register',methods=['POST'])
   
2.     defregister_nodes():
   
3.     values=request.get_json()
   
4.     nodes=values.get('nodes')
   
5.     ifnodesisNone:
   
6.     return"Error:Pleasesupplyavalidlistofnodes",400
   
7.     fornodeinnodes:
   
8.     blockchain.register_node(node)
   
9.     response={
   
10.     'message':'Newnodeshavebeenadded',
    
11.     'total_nodes':list(blockchain.nodes),
    
12.     }
    
13.     returnjsonify(response),201
    
14.     @app.route('/nodes/resolve',methods=['GET'])
    
15.     defconsensus():
    
16.     replaced=blockchain.resolve_conflicts()
    
17.     ifreplaced:
    
18.     response={
    
19.     'message':'Ourchainwasreplaced',
    
20.     'new_chain':blockchain.chain
    
21.     }
    
22.     else:
    
23.     response={
    
24.     'message':'Ourchainisauthoritative',
    
25.     'chain':blockchain.chain
    
26.     }
    
27.     returnjsonify(response),200
    
28.     ```

Copy the Code

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

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