角逐选题 python区块链实现 - proof of work工作量证明共识算法

0 前言

🔥 优质角逐项目系列，本日要分享的是
python区块链实现 - proof of work工作量证明共识算法
该项目较为新奇，适相助为角逐课题方向，学长非常保举！
🧿 更多资料, 项目分享：
https://gitee.com/dancheng-senior/postgraduate

1 区块链底子

学长以比特币的结构向各人详解区块链的构成部门
1.1 比特币内部结构

• previous hash(前一个区块的hash)
  
• merkle root(默克尔树根节点,内部存储买卖业务数据)
  
• timestamp(当前区块天生的时间)
  
• nonce(旷工盘算hash值次数)
  

1.2 实现的区块链数据结构

• index 当前第几个区块
  
• timestamp 该区块创建时的时间戳
  
• data 买卖业务信息
  
• previousHash 前一个区块的hash
  
• hash 当前区块的hash
  

1.3 注意点

第一个区块叫做创世区块(genesis block),区块链创建的时间默认生产的这里用的是单纯的链表,不是用默克尔树存储
示例代码
​

3.     from hashlib import sha256
4.     //区块schema
5.     class Block:
6.          
7.         def __init__(self,index,timestamp,data,previousHash=""):
8.             
9.             self.index = index
10.             self.timestamp = timestamp
11.             self.data = data
12.             self.previousHash = previousHash
13.             self.hash = self.calculateHash()
14.             
15.         //计算当前区块的hash值
16.         def calculateHash(self):
17.             plainData = str(self.index)+str(self.timestamp)+str(self.data)
18.             return sha256(plainData.encode('utf-8')).hexdigest()
19.         
20.         def __str__(self):
21.             return str(self.__dict__)
22.      //区块链schema
23.     class BlockChain:
24.         //初始化的时候 创建 创世区块
25.         def __init__(self):
26.             self.chain = [self.createGenesisBlock()]
27.         //构建创世区块
28.         def createGenesisBlock(self):
29.             return Block(0,"01/01/2018","genesis block","0")
30.         //获取最后一个区块
31.         def getLatestBlock(self):
32.             return self.chain[len(self.chain)-1]
33.         //往区块链里面添加区块
34.         def addBlock(self,newBlock):
35.             newBlock.previousHash = self.getLatestBlock().hash
36.             newBlock.hash = newBlock.calculateHash()
37.             self.chain.append(newBlock)
38.         
39.         def __str__(self):
40.             return str(self.__dict__)   
41.         //校验区块链是不是有效的 有没有人被篡改
42.         def chainIsValid(self):
43.             for index in range(1,len(self.chain)):
44.                 currentBlock = self.chain[index]
45.                 previousBlock = self.chain[index-1]
46.                 if (currentBlock.hash != currentBlock.calculateHash()):
47.                     return False
48.                 if previousBlock.hash != currentBlock.previousHash:
49.                     return False
50.             return True
53. myCoin = BlockChain()
54. myCoin.addBlock(Block(1,"02/01/2018","{amount:4}"))
55. myCoin.addBlock(Block(2,"03/01/2018","{amount:5}"))
57. #print block info 打印区块链信息
58. print("print block info ####:")
59. for block in myCoin.chain:
60.     print(block)
61. #check blockchain is valid 检查区块链是不是有效的
62. print("before tamper block,blockchain is valid ###")
63. print(myCoin.chainIsValid())
64. #tamper the blockinfo  篡改区块2的数据
65. myCoin.chain[1].data = "{amount:1002}"
66. print("after tamper block,blockchain is valid ###")
67. print(myCoin.chainIsValid())

复制代码

输出效果
​

1. print block info ####:
2. {'index': 0, 'timestamp': '01/01/2018', 'data': 'genesis block', 'previousHash': '0', 'hash': 'd8d21e5ba33780d5eb77d09d3b407ceb8ade4e5545ef951de1997b209d91e264'}
3. {'index': 1, 'timestamp': '02/01/2018', 'data': '{amount:4}', 'previousHash': 'd8d21e5ba33780d5eb77d09d3b407ceb8ade4e5545ef951de1997b209d91e264', 'hash': '15426e32db30f4b26aa719ba5e573f372f41e27e4728eb9e9ab0bea8eae63a9d'}
4. {'index': 2, 'timestamp': '03/01/2018', 'data': '{amount:5}', 'previousHash': '15426e32db30f4b26aa719ba5e573f372f41e27e4728eb9e9ab0bea8eae63a9d', 'hash': '75119e897f21c769acee6e32abcefc5e88e250a1f35cc95946379436050ac2f0'}
5. before tamper block,blockchain is valid ###
6. True
7. after tamper block,blockchain is valid ###
8. False

复制代码

1.4 区块链的焦点-工作量证明算法

上面学长先容了区块链的根本结构,我在之前的底子上来简朴实现一下工作量证明算法(proof of
work),在先容pow之前先思索一下为什么要工作量证明算法,大概再往前想一步为什么比特币怎样办理信托的题目?
1.4.1 拜占庭将军题目

比特币出现之前就有了拜占庭将军题目,重要头脑是,如安在分布式体系环境里去信赖其他人发给你的信息？
一组拜占庭将军分别各向导一支部队共同围困一座都会。为了简化题目，将各支部队的举措计谋限定为打击或撤离两种。由于部门部队打击部门部队撤离大概会造成灾难性结果，因此各位将军必须通过投票来告竣同等计谋，即全部部队一起打击或全部部队一起撤离。由于各位将军分处都会差别方向，他
体系的题目在于，将军中大概出现叛徒，他们不光大概向较为糟糕的计谋投票，还大概选择性地发送投票信息。假设有9位将军投票，此中1名叛徒。8名忠诚的将军中出现了4人投打击，4人投撤离的环境。这时间叛徒大概故意给4名投打击的将领送信表现投票打击，而给4名投撤离的将领送信表现投撤离。如许一来在4名投打击的将领看来，投票效果是5人投打击，从而发起打击；而在4名投撤离的将军看来则是5人投撤离。如许各支部队的同等协同就遭到了粉碎。

1.4.2 办理办法

拜占庭将军题目重要题目是,中央人可以拦截消息,举行修改;上述的那些士兵可以明确成比特币中的一些节点,不是全部节点拿到消息后都是可以直接处理惩罚的,先去办理一个数学题目,就是工作量证明,只有拥有特定的盘算本领办理了题目之后才气去修改大概校验(验证,打包,上链)。

上图就是简朴的工作量证明算法流程,一串数字反面有个x,x之前的数可以明确成买卖业务数据,然后必要找到一个x,让整个数的hash值的开头有n个0,如果hash是很匀称的话,那么天生的hash值每一位为0大概1都是等大概的,以是前n个都为0的概率就是2的n次方/2的hash值位数,上图给出了如果hash值是5个bit的环境下的全部大概
1.4.3 代码实现

​

3.     from hashlib import sha256
4.     import time
5.     class Block:
6.          
7.         def __init__(self,index,timestamp,data,previousHash=""):
8.             
9.             self.index = index
10.             self.timestamp = timestamp
11.             self.data = data
12.             self.previousHash = previousHash
13.             self.nonce = 0 //代表当前计算了多少次hash计算
14.             self.hash = self.calculateHash()
17.         def calculateHash(self):
18.             plainData = str(self.index)+str(self.timestamp)+str(self.data)+str(self.nonce)
19.             return sha256(plainData.encode('utf-8')).hexdigest()
20.         #挖矿 difficulty代表复杂度 表示前difficulty位都为0才算成功
21.         def minerBlock(self,difficulty):
22.             while(self.hash[0:difficulty]!=str(0).zfill(difficulty)):
23.                 self.nonce+=1
24.                 self.hash = self.calculateHash()
25.         
26.         def __str__(self):
27.             return str(self.__dict__)
30.     class BlockChain:
31.         
32.         def __init__(self):
33.             self.chain = [self.createGenesisBlock()]
34.             self.difficulty = 5
35.    
36.         def createGenesisBlock(self):
37.             return Block(0,"01/01/2018","genesis block")
38.         
39.         def getLatestBlock(self):
40.             return self.chain[len(self.chain)-1]
41.         #添加区块前需要 做一道计算题😶,坐完后才能把区块加入到链上
42.         def addBlock(self,newBlock):
43.             newBlock.previousHash = self.getLatestBlock().hash
44.             newBlock.minerBlock(self.difficulty)
45.             self.chain.append(newBlock)
47.         def __str__(self):
48.             return str(self.__dict__)   
49.         
50.         def chainIsValid(self):
51.             for index in range(1,len(self.chain)):
52.                 currentBlock = self.chain[index]
53.                 previousBlock = self.chain[index-1]
54.                 if (currentBlock.hash != currentBlock.calculateHash()):
55.                     return False
56.                 if previousBlock.hash != currentBlock.previousHash:
57.                     return False
58.             return True
59.            
61.     myCoin = BlockChain()
62.    
63.     # 下面打印了每个区块挖掘需要的时间 比特币通过一定的机制控制在10分钟出一个块
64.     # 其实就是根据当前网络算力 调整我们上面difficulty值的大小,如果你在
65.     # 本地把上面代码difficulty的值调很大你可以看到很久都不会出计算结果
66.     startMinerFirstBlockTime = time.time()
67.     print("start to miner first block time :"+str(startMinerFirstBlockTime))
68.    
69.     myCoin.addBlock(Block(1,"02/01/2018","{amount:4}"))
70.    
71.     print("miner first block time completed" + ",used " +str(time.time()-startMinerFirstBlockTime) +"s")
72.    
73.     startMinerSecondBlockTime = time.time()
74.    
75.     print("start to miner first block time :"+str(startMinerSecondBlockTime))
76.    
77.     myCoin.addBlock(Block(2,"03/01/2018","{amount:5}"))
78.    
79.     print("miner second block time completed" + ",used " +str(time.time()-startMinerSecondBlockTime) +"s\n")
80.    
81.     #print block info
82.     print("print block info ####:\n")
83.     for block in myCoin.chain:
84.         print("\n")
85.         print(block)
86.         
87.     #check blockchain is valid
88.     print("before tamper block,blockchain is valid ###")
89.     print(myCoin.chainIsValid())
90.    
91.     #tamper the blockinfo
92.     myCoin.chain[1].data = "{amount:1002}"
93.     print("after tamper block,blockchain is valid ###")
94.     print(myCoin.chainIsValid())

复制代码

输出

2 快速实现一个区块链

2.1 什么是区块链

区块链是一个不可变得，有序的被称之为块的纪录链，它们可以包罗买卖业务、文件大概任何你喜欢的数据，但最告急的是，它们用hash毗连在一起。
2.2 一个完备的快包罗什么

一个索引，一个时间戳，一个事物列表，一个校验， 一个前快的散链表
2.3 什么是挖矿

挖矿着实非常简朴就做了以下三件事：
1、盘算工作量证明poW
2、通过新增一个买卖业务赋予矿工（自已）一个币
3、构造新区块并将其添加到链中
2.4 工作量证明算法：

使用该算法来证明是如安在区块上创建和发掘新的区块，pow的目的是盘算出一个符合特定条件的数字，这个数字对于全部人而言必须在盘算上非常困难，但易于验证，这就是工作证明背后的焦颔首脑盘算难度与目的字符串必要满意的特定字符串成正比。
2.5 实当代码

​

3.     import hashlib
4.     import json
5.     import requests
6.     from textwrap import dedent
7.     from time import time
8.     from uuid import uuid4
9.     from urllib.parse import urlparse
10.     from flask import Flask, jsonify, request
11.    
12.     class Blockchain(object):
13.         def __init__(self):
14.             ...
15.             self.nodes = set()
16.             # 用 set 来储存节点，避免重复添加节点.
17.             ...
18.             self.chain = []
19.             self.current_transactions = []
20.    
21.             #创建创世区块
22.             self.new_block(previous_hash=1,proof=100)
23.    
24.         def reister_node(self,address):
25.             """
26.             在节点列表中添加一个新节点
27.             :param address:
28.             :return:
29.             """
30.             prsed_url = urlparse(address)
31.             self.nodes.add(prsed_url.netloc)
32.    
33.         def valid_chain(self,chain):
34.             """
35.             确定一个给定的区块链是否有效
36.             :param chain:
37.             :return:
38.             """
39.             last_block = chain[0]
40.             current_index = 1
41.    
42.             while current_index<len(chain):
43.                 block = chain[current_index]
44.                 print(f'{last_block}')
45.                 print(f'{block}')
46.                 print("\n______\n")
47.                 # 检查block的散列是否正确
48.                 if block['previous_hash'] != self.hash(last_block):
49.                     return False
50.                 # 检查工作证明是否正确
51.                 if not self.valid_proof(last_block['proof'], block['proof']):
52.                     return False
53.    
54.                 last_block = block
55.                 current_index += 1
56.             return True
58.         def ressolve_conflicts(self):
59.             """
60.             共识算法
61.             :return:
62.             """
63.             neighbours = self.nodes
64.             new_chain = None
65.             # 寻找最长链条
66.             max_length = len(self.chain)
67.    
68.             # 获取并验证网络中的所有节点的链
69.             for node in neighbours:
70.                 response = requests.get(f'http://{node}/chain')
71.    
72.                 if response.status_code == 200:
73.                     length = response.json()['length']
74.                     chain = response.json()['chain']
75.    
76.                     # 检查长度是否长，链是否有效
77.                     if length > max_length and self.valid_chain(chain):
78.                         max_length = length
79.                         new_chain = chain
80.    
81.             # 如果发现一个新的有效链比当前的长，就替换当前的链
82.             if new_chain:
83.                 self.chain = new_chain
84.                 return True
85.             return False
86.    
87.         def new_block(self,proof,previous_hash=None):
88.             """
89.             创建一个新的块并将其添加到链中
90.             :param proof: 由工作证明算法生成证明
91.             :param previous_hash: 前一个区块的hash值
92.             :return: 新区块
93.             """
94.             block = {
95.                 'index':len(self.chain)+1,
96.                 'timestamp':time(),
97.                 'transactions':self.current_transactions,
98.                 'proof':proof,
99.                 'previous_hash':previous_hash or self.hash(self.chain[-1]),
100.             }
101.    
102.             # 重置当前交易记录
103.             self.current_transactions = []
104.    
105.             self.chain.append(block)
106.             return block
107.    
108.         def new_transaction(self,sender,recipient,amount):
109.             # 将新事务添加到事务列表中
110.             """
111.             Creates a new transaction to go into the next mined Block
112.             :param sender:发送方的地址
113.             :param recipient:收信人地址
114.             :param amount:数量
115.             :return:保存该事务的块的索引
116.             """
117.             self.current_transactions.append({
118.                 'sender':sender,
119.                 'recipient':recipient,
120.                 'amount':amount,
121.             })
122.    
123.             return  self.last_block['index'] + 1
125.         @staticmethod
126.         def hash(block):
127.             """
128.             给一个区块生成 SHA-256 值
129.             :param block:
130.             :return:
131.             """
132.             # 必须确保这个字典（区块）是经过排序的，否则将会得到不一致的散列
133.             block_string = json.dumps(block,sort_keys=True).encode()
134.             return hashlib.sha256(block_string).hexdigest()
135.    
136.         @property
137.         def last_block(self):
138.             # 返回链中的最后一个块
139.             return self.chain[-1]
141.         def proof_of_work(self,last_proof):
142.             # 工作算法的简单证明
143.             proof = 0
144.             while self.valid_proof(last_proof,proof)is False:
145.                 proof +=1
146.             return proof
147.    
148.         @staticmethod
149.         def valid_proof(last_proof,proof):
150.             # 验证证明
151.             guess =  f'{last_proof}{proof}'.encode()
152.             guess_hash = hashlib.sha256(guess).hexdigest()
153.             return guess_hash[:4] =="0000"
156.     # 实例化节点
157.     app = Flask(__name__)
158.    
159.     # 为该节点生成一个全局惟一的地址
160.     node_identifier = str(uuid4()).replace('-','')
161.    
162.     # 实例化Blockchain类
163.     blockchain = Blockchain()
164.    
165.     # 进行挖矿请求
166.     @app.route('/mine',methods=['GET'])
167.     def mine():
168.         # 运行工作算法的证明来获得下一个证明。
169.         last_block = blockchain.last_block
170.         last_proof = last_block['proof']
171.         proof = blockchain.proof_of_work(last_proof)
172.    
173.         # 必须得到一份寻找证据的奖赏。
174.         blockchain.new_transaction(
175.             sender="0",
176.             recipient=node_identifier,
177.             amount=1,
178.         )
179.    
180.         # 通过将其添加到链中来构建新的块
181.         previous_hash = blockchain.hash(last_block)
182.         block = blockchain.new_block(proof,previous_hash)
183.         response = {
184.             'message': "New Block Forged",
185.             'index': block['index'],
186.             'transactions': block['transactions'],
187.             'proof': block['proof'],
188.             'previous_hash': block['previous_hash'],
189.         }
190.         return jsonify(response), 200
191.    
192.     # 创建交易请求
193.     @app.route('/transactions/new',methods=['POST'])
194.     def new_transactions():
195.         values = request.get_json()
196.    
197.         # 检查所需要的字段是否位于POST的data中
198.         required = ['seder','recipient','amount']
199.         if not all(k in values for k in request):
200.             return 'Missing values',400
201.    
202.         #创建一个新的事物
203.         index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
204.         response = {'message': f'Transaction will be added to Block {index}'}
205.         return jsonify(response), 201
206.    
207.     # 获取所有快信息
208.     @app.route('/chain',methods=['GET'])
209.     def full_chain():
210.         response = {
211.             'chain':blockchain.chain,
212.             'length':len(blockchain.chain),
213.         }
214.         return jsonify(response),200
215.    
216.     # 添加节点
217.     @app.route('/nodes/register',methods=['POST'])
218.     def  register_nodes():
219.         values = request.get_json()
220.         nodes = values.get('nodes')
221.         if nodes is None:
222.             return "Error: Please supply a valid list of nodes", 400
223.    
224.         for node in nodes:
225.             blockchain.register_node(node)
226.    
227.         response = {
228.             'message': 'New nodes have been added',
229.             'total_nodes': list(blockchain.nodes),
230.         }
231.         return jsonify(response), 201
232.    
233.     # 解决冲突
234.     @app.route('/nodes/resolve', methods=['GET'])
235.     def consensus():
236.         replaced = blockchain.resolve_conflicts()
237.    
238.         if replaced:
239.             response = {
240.                 'message': 'Our chain was replaced',
241.                 'new_chain': blockchain.chain
242.             }
243.         else:
244.             response = {
245.                 'message': 'Our chain is authoritative',
246.                 'chain': blockchain.chain
247.             }
248.    
249.         return jsonify(response), 200
250.    
251.     if __name__ == '__main__':
252.         app.run(host='0.0.0.0',port=5000)

复制代码

代码弄好启动你的项目以后打开Postman 完成以下操纵

学长通过哀求 http://localhost:5000/mine举行采矿

3 末了

🧿 更多资料, 项目分享：
https://gitee.com/dancheng-senior/postgraduate

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金