用python实现区块链简单原理

本是古典 何须时尚 2023-07-07 12:55 78阅读 0赞

1.设置好区块链的对应方法

  1. #一个区块应该包括的内容
  2. # { 
  3. # 'index':0, #索引
  4. # 'timestamp':"", #时间戳
  5. # 'trascations':[ #交易信息
  6. # {"sender":"", #交易发送者
  7. # recipient":"",#交易接收者
  8. # "amout":""} #转账金额
  9. # ],
  10. # 'proof':"",#工作量证明
  11. # 'previous_hash':"" #上一个交易的hash值
  12. # }
  13. import hashlib
  14. import json
  15. from time import time
  16. from urllib.parse import urlparse
  18. import requests
  21. class Blokchain:
  22.     def __init__(self):
  23.         self.chain=[]
  24.         #准备好一个存储当前交易记录的列表
  25.         self.current_trascations=[]
  26.         #准备实现一个创世纪的区块，其参数值可以是任意的
  27.         self.new_block(proof=1,previous_hash=1)
  28.         #准备好变量保存节点信息
  29.         self.nodes=set()
  30.     #注册节点,保存好节点的网络信息
  31.     def register_node(self,address:str):
  32.         parsed_url=urlparse(address)
  33.         self.nodes.add(parsed_url.netloc)
  34.     #解决冲突，实现共识机制
  35.     def resolve_conflics(self):
  36.         neighbours=self.nodes
  37.         max_length=len(self.chain)
  38.         new_chain=None
  39.         for node in neighbours:
  40.             response=requests.get(f'http://{node}/chain')
  41.             if response.status_code==200:
  42.                 length=response.json()['length']
  43.                 chain=response.json()['chain']
  44.                 if length>max_length and self.valid_chain(chain):
  45.                     max_length=length
  46.                     new_chain=chain
  47.         if new_chain:
  48.             self.chain=new_chain
  49.             return True
  50.         return False
  52.     #添加一个新的区块
  53.     def new_block(self,proof,previous_hash=None):
  54.         #准备一个新的区块
  55.         block={ 
  56.         'index':len(self.chain)+1,
  57.         'timestamp':time(),
  58.         'trascations':self.current_trascations,
  59.         'proof':proof,
  60.         'previous_hash':previous_hash or self.hash(self.last_block)
  61.         }
  62.         #清空新的交易
  63.         self.current_trascations=[]
  64.         #把区块加入链条中
  65.         self.chain.append(block)
  66.         return block
  67.     #创建一个新的交易
  68.     def new_trascations(self,sender,recipient,amout):
  69.         ''' :param sender: 交易的发送者 :param recipient: 交易的接收者 :param amout: 交易的金额 :return: 整型，返回创建新区块链的索引。 '''
  70.         self.current_trascations.append({ 
  71.             'sender':sender,
  72.             'recipient':recipient,
  73.             'amout':amout
  74.         })
  75.         return self.last_block['index']+1
  77.     #计算一个区块的hash值，使用静态方法
  78.     @staticmethod
  79.     def hash(block):
  80.         #把节点传入的信息进行转化为字节串，并编码,这样hash函数才能够认识
  81.         block_string=json.dumps(block,sort_keys=True).encode()
  82.         #进行hash计算得到的是一个对象，进行hesdidest()方法得到hash摘要
  83.         return  hashlib.sha256(block_string).hexdigest()
  84.     #获取一个最后一个区块。当做属性来处理
  85.     @property
  86.     def last_block(self):
  87.         return self.chain[-1]
  88.     #实现工作量证明，为了简化操作，我们就用上一个区块链的（hash值）工作量证明来验证
  89.     def proof_of_work(self,last_proof):
  90.         proof=0
  91.         while self.valid_proof(last_proof,proof) is False:
  92.             proof+=1
  93.         print(proof)
  94.         return proof   #返回工作量证明
  96.     #验证工作量的合法性
  97.     def valid_proof(self,last_proof,proof):
  98.         #把last_proof和proof拼接在一起，进行编码
  99.         guess=f'{last_proof}{proof}'.encode()
  100.         guess_hash=hashlib.sha256(guess).hexdigest()
  101.         print(guess_hash)
  102.         #说明工作强度，返回一个bool值
  103.         return guess_hash[0:4]=='0000'
  104.     #判断链条是否为有效链条
  105.     def valid_chain(self, chain):
  106.         last_block=chain[0]
  107.         current_index=1
  108.         while current_index<len(chain):
  109.             block=chain[current_index]
  110.             #如果上一块链的hash值不等于，则说明是假的
  111.             if block['previous_hash']!=self.hash(last_block):
  112.                 return False
  113.             #判断工作量证明
  114.             if not self.valid_proof(last_block['proof'],block['proof']):
  115.                 return False
  116.             #如果都满足则解决对应问题
  117.             last_block=block
  118.             current_index+=1
  119.         return True
  122. if __name__=="__main__":
  123.     testPow=Blokchain()
  124.     testPow.proof_of_work(100)

2通过flask 实现网络节点的调用

  1. ''' 设置网络模拟，区块链中各个节点的运行原理 '''
  2. from uuid import uuid4
  4. from blockchain import Blokchain
  5. import flask
  6. import requests
  7. from flask import Flask, jsonify, request
  9. block_chain=Blokchain()
  10. #初始化一个Flask
  11. app=Flask(__name__)
  12. #实现创建一个新的交易
  13. @app.route('/transction/new',methods=['POST'])
  14. def new_transction():
  15.     values=request.get_json()
  16.     #判断获取的信息在不在范围内
  17.     required=['sender','recipient','amout']
  18.     if values==None:
  19.         return 'Miss values !', 400
  20.     #如果请求不在范围require的列表内，则返回错误
  21.     if not all(k in values for k in required):
  22.         return 'Miss values !',400
  23.     index=block_chain.new_trascations(values['sender'],values['recipient'],values['amout'])
  24.     response={ 'message':f'Transction will be added to Block {index}'}
  25.     return jsonify(response),201
  26. #引入一个计算地址的库，保存好地址
  27. node_identifier=str(uuid4().replace('-',''))
  29. #实现挖矿（实现交易的打包）
  30. @app.route('/mine',methods=['GET'])
  31. def mine():
  32.     last_block=block_chain.last_block
  33.     last_proof=last_block['proof']
  35.     proof=block_chain.proof_of_work(last_proof)
  36.     # 完成一笔交易，给自己一点奖励
  37.     block_chain.new_trascations(sender='0',
  38.                                 recipient=node_identifier,
  39.                                 amout=1)
  40.     block=block_chain.new_block(proof,None)#给区块新建一个区块
  41.     #打包好区块，广播给各个节点
  42.     response={ 
  43.         "message":'Now block forgod',
  44.         'index':block['index'],
  45.         'transactions':block['transactions'],
  46.         'proof':block['proof'],
  47.         'previous_hash':block['previous_hash']
  48.     }
  49.     return jsonify(response),200
  51. #实现增加一个节点
  52. @app.route('/chain',methods=['GET'])
  53. def chain():
  54.     response={ 
  55.         'chain':block_chain.chain,
  56.         'length':len(block_chain.chain)
  57.     }
  58.     return jsonify(response),200
  59. #接收用户的节点注册:所接收的json字符串格式为{"nodes",["http:127.XXX]}
  60. @app.route('nodes/register',methods=['POST'])
  61. def register_nodes():
  62.     values=request.get_json()
  63.     nodes=values.get('nodes')
  64.     if nodes is None:
  65.         return "Error:please supply a valid list of nodes",400
  66.     response={ 
  67.         "message":"New nodes have been added",
  68.         "total_nodes":list(block_chain.nodes)
  69.     }
  70.     return jsonify(response),201
  71. #设置达成共识的请求，解决冲突
  72. @app.route('/nodes/resolve',methods=['GET'])
  73. def consensus():
  74.     replace=block_chain.resolve_conflics()
  75.     if replace:
  76.         response={ 
  77.             'message':"our chain was replaced",
  78.             'chain':block_chain.chain
  79.         }
  80.     else:
  81.         response = { 
  82.             'message': "our chain was authoritative",
  83.             'chain': block_chain.chain
  84.         }
  85.     return jsonify(response),200
  86. if __name__=='__main__':
  87.     app.run(host='0.0.0.0', port=6000)

发表评论

表情：
评论列表 （有 0 条评论，78人围观）

还没有评论，来说两句吧...

相关阅读

    相关 简单区块链Python实现

    什么是区块链 区块链是一种数据结构，也是一个分布式数据库。 从技术上来看：区块是一种记录交易的数据结构，反映了一笔交易的资金流向。系统中已经达成的交易的区块连接在一起形

    快来打我*快来打我*/ 0 赞/ 120 阅读

    相关 Python & 区块链

    一个完整的区块栗子 每个区块都有其索引，时间戳（Unix 时间），交易列表，证明 proof（稍后解释），以及前序区块的哈希值。 block = {

    蔚落蔚落/ 0 赞/ 234 阅读

    相关 区块链技术原理

     区块链是什么？     “区块链”技术最初是由一位化名中本聪的人为比特币（一种数字货币）而设计出的一种特殊的数据库技术，它基于密码学中的椭圆曲线数字签名算法（ECDSA

    柔光的暖阳◎柔光的暖阳◎/ 0 赞/ 380 阅读

    相关 区块链 简单实现介绍

    区块链的基础概念很简单：一个分布式数据库，存储一个不断加长的 list，list 中包含着许多有序的记录。然而，在通常情况下，当我们谈到区块链的时候也会谈起使用区块链来解决的问

    快来打我*快来打我*/ 0 赞/ 637 阅读