用python自己搭建区块链_python搭建区块链

#!/usr/bin/env python

# encoding: utf-8

'''

我们要创建一个 Blockchain 类 ，他的构造函数创建了一个初始化的空列表(要存储我们的区块链)，并且另一个存储交易。

我们的 Blockchain 类负责管理链式数据，它会存储交易并且还有添加新的区块到链式数据的Method。

'''

import hashlib

import json

import time

from textwrap import dedent

from uuid import uuid4

from flask import Flask,jsonify,request

class Blockchain(object):

def __init__(self):

self.chain=[]

self.current_transations=[]

## 创建创世区块，源区块，第一个区块前面没了。

self.new_block(previous_hash=1,proof=100)

def new_block(self,previous_hash,proof):

'''

创建一个新的区块到区块链

:param previous_hash:前一个区块的hash值

:param proof: 由工作量证明(PoW)算法生成的证明

:return: 返回新的区块

'''

block={

'index':len(self.chain)+1,

'timestamp':time.time(),

'transactions':self.current_transations,

'proof':proof,

'previous_hash':previous_hash or self.hash(self.chain[-1])

}

#重置当前交易记录

self.current_transations=[]

self.chain.append(block)

return block

def new_transation(self,sender,recipient,amount):

# Adds a new transaction to the list of transactions

'''

创建一笔新的交易到下一个被挖掘的区块中

:param sender: 发送者

:param recipient: 接收方

:param amount: 发送数量

:return: 返回将被添加到的区块的索引

'''

self.current_transations.append({

'sender':sender,

'recipient':recipient,

'amount':amount,

})

return self.last_block['index']+1

@staticmethod

def hash(block):

'''

给一个区块生成SHA-256值

:param block: Block

:return: 返回hash值

'''

#我们相比下确保这个字典(区块)是经过排序的，否则我们将会得到不一致的散列

block_string=json.dumps(block,sort_keys=True).encode()

return hashlib.sha256(block_string).hexdigest()

#@property装饰器就是负责把一个方法变成属性调用的

@property

def last_block(self):

# Returns the last Block in the chain

return self.chain[-1]

#每个块都有一个 索引，一个 时间戳(Unix时间戳)，一个事务列表， 一个 校验(稍后详述) 和 前一个块的散列 。

"""

实现工作量证明

让我们来实现一个相似 PoW 算法。规则类似上面的例子：

找到一个数字 P ，使得它与前一个区块的 proof 拼接成的字符串的 Hash 值以 4 个零开头。

衡量算法复杂度的办法是修改零开头的个数。使用 4 个来用于演示，你会发现多一个零都会大大增加计算出结果所需的时间。

"""

def proof_of_work(self,last_proof):

'''

:param last_proof:

:return:

'''

proof=0

while self.valid_proof(last_proof,proof) is False:

proof+=1

return proof

@staticmethod

def valid_proof(last_proof,proof):

'''

:param last_proof: 上一个pow算法

:param proof: 现在的pow算法

:return:

'''

guess=f'{last_proof}{proof}'.encode()

guess_hash=hashlib.sha256(guess).hexdigest()

return guess_hash[:4]=="0000"

app=Flask(__name__)

node_identity=str(uuid4()).replace('-','')

blockchain=Blockchain()

@app.route('/')

@app.route('/mine',methods=['GET'])

def mine():

# 挖矿

# 挖矿正是神奇所在，它很简单，做了一下三件事：

#

# 计算工作量证明 PoW

# 通过新增一个交易授予矿工(自己)一个币

# 构造新区块并将其添加到链中

# We run the proof of work algorithm to get the next proof...

last_block=blockchain.last_block

last_proof=last_block['proof']

proof=blockchain.proof_of_work(last_proof)

# We must receive a reward for finding the proof.

# The sender is "0" to signify that this node has mined a new coin.

blockchain.new_transation(

sender="0",

recipient=node_identity,

amount=1,

)

# Forge the new Block by adding it to the chain

previous_hash=blockchain.hash(last_block)

block=blockchain.new_block(proof,previous_hash)

response={

'message': "New Block Forged",

'index': block['index'],

'transactions': block['transactions'],

'proof': block['proof'],

'previous_hash': block['previous_hash'],

}

return jsonify(response),200

@app.route('/transactions/new',methods=['POST'])

def new_transaction():

'''

我们将添加一个新的事务处理

:return:

'''

values=request.get_json()

required=['sender','recipient','amount']

if not all(k in values for k in required):

return "Missing values", 400

#创建一个新的事务

index=blockchain.new_transation(values['sender'],values['recipient'],values['amount'])

response={'message':f'在区块上添加事务{index}'}

return jsonify(response),201

@app.route('/chain',methods=['GET'])

def full_chain():

a_chain=blockchain.chain

response={

'chain':a_chain,

'length':len(a_chain),

}

return jsonify(response),200

if __name__=="__main__":

app.run(debug=True)

# 注意交易的接收者是我们自己的服务器节点，我们做的大部分工作都只是围绕 Blockchain 类方法进行交互。

# 到此，我们的区块链就算完成了，我们来实际运行下.