Hi Guest

More contents, please log on!

Bitmere.com 区块链技术 Content

用 Python 从零开始创建区块链

江左没浪
176 3 0
我们都对比特币的崛起感到惊讶惊奇,并且想知道其背后的技术——区块链是如何实现的。
    但是完全搞懂区块链并非易事,至少对我来讲是这样。我喜欢在实践中学习,通过写代码来学习技术会掌握得更牢固。通过构建一个区块链可以加深对区块链的理解。
    准备工作
    我们知道区块链是由区块的记录构成的不可变、有序的链结构,记录可以是交易、文件或任何你想要的数据,重要的是它们是通过哈希值(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的链取代。
Tags: Python
BitMere.com is Information release platform,just provides information storage space services.
The opinions expressed are solely those of the author,Does not constitute advice, please treat with caution.
You have to log in before you can reply Login | 立即注册

Points Rules

Write the first review

江左没浪 小学生
  • Follow

    18

  • Following

    0

  • Articles

    7

币圈江左盟
Promoted