区块链实现代码详细分析（Python）

代码

import hashlib
import json
import requests
from textwrap import dedent
from time import time
from uuid import uuid4
from urllib.parse import urlparse
from flask import Flask, jsonify, request


class Blockchain(object):
    def __init__(self):
        ...
        self.nodes = set()
        # 用 set 来储存节点，避免重复添加节点.
        ...
        self.chain = []
        self.current_transactions = []

        # 创建创世区块
        self.new_block(previous_hash=1, proof=100)

    def reister_node(self, address):
        """
        在节点列表中添加一个新节点
        :param address:
        :return:
        """
        prsed_url = urlparse(address)
        self.nodes.add(prsed_url.netloc)

    def valid_chain(self, chain):
        """
        确定一个给定的区块链是否有效
        :param chain:
        :return:
        """
        last_block = chain[0]
        current_index = 1

        while current_index < len(chain):
            block = chain[current_index]
            print('{}'.format(last_block))
            print('{}'.format(block))
            print("\n______\n")
            # 检查block的散列是否正确
            if block['previous_hash'] != self.hash(last_block):
                return False
            # 检查工作证明是否正确
            if not self.valid_proof(last_block['proof'], block['proof']):
                return False

            last_block = block
            current_index += 1
        return True

    def ressolve_conflicts(self):
        """
        共识算法
        :return:
        """
        neighbours = self.nodes
        new_chain = None
        # 寻找最长链条
        max_length = len(self.chain)

        # 获取并验证网络中的所有节点的链
        for node in neighbours:
            response = requests.get('http://{}/chain'.format(node))

            if response.status_code == 200:
                length = response.json()['length']
                chain = response.json()['chain']

                # 检查长度是否长，链是否有效
                if length > max_length and self.valid_chain(chain):
                    max_length = length
                    new_chain = chain

        # 如果发现一个新的有效链比当前的长，就替换当前的链
        if new_chain:
            self.chain = new_chain
            return True
        return False

    def new_block(self, proof, previous_hash=None):
        """
        创建一个新的块并将其添加到链中
        :param proof: 由工作证明算法生成证明
        :param previous_hash: 前一个区块的hash值
        :return: 新区块
        """
        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

        # 重置当前交易记录
        self.current_transactions = []

        self.chain.append(block)
        return block

    def new_transaction(self, sender, recipient, amount):
        # 将新事务添加到事务列表中
        """
        Creates a new transaction to go into the next mined Block
        :param sender:发送方的地址
        :param recipient:收信人地址
        :param amount:数量
        :return:保存该事务的块的索引
        """
        self.current_transactions.append({
            'sender': sender,
            'recipient': recipient,
            'amount': amount,
        })

        return self.last_block['index'] + 1

    @staticmethod
    def hash(block):
        """
        给一个区块生成 SHA-256 值
        :param block:
        :return:
        """
        # 必须确保这个字典（区块）是经过排序的，否则将会得到不一致的散列
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

    @property
    def last_block(self):
        # 返回链中的最后一个块
        return self.chain[-1]

    def proof_of_work(self, last_proof):
        # 工作算法的简单证明
        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1
        return proof

    @staticmethod
    def valid_proof(last_proof, proof):
        # 验证证明
        guess = ('{}{}'.format(last_proof, proof)).encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"


# 实例化节点
app = Flask(__name__)

# 为该节点生成一个全局惟一的地址
node_identifier = str(uuid4()).replace('-', '')

# 实例化Blockchain类
blockchain = Blockchain()


# 进行挖矿请求
@app.route('/mine', methods=['GET'])
def mine():
    # 运行工作算法的证明来获得下一个证明。
    last_block = blockchain.last_block
    last_proof = last_block['proof']
    proof = blockchain.proof_of_work(last_proof)

    # 必须得到一份寻找证据的奖赏。
    blockchain.new_transaction(
        sender="0",
        recipient=node_identifier,
        amount=1,
    )

    # 通过将其添加到链中来构建新的块
    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_transactions():
    values = request.get_json()

    # 检查所需要的字段是否位于POST的data中
    required = ['seder', 'recipient', 'amount']
    if not all(k in values for k in request):
        return 'Missing values', 400

    # 创建一个新的事物
    index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
    response = {'message': 'Transaction will be added to Block {}'.format(index)}
    return jsonify(response), 201


# 获取所有快信息
@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        'chain': blockchain.chain,
        'length': len(blockchain.chain),
    }
    return jsonify(response), 200


# 添加节点
@app.route('/nodes/register', methods=['POST'])
def register_nodes():
    values = request.get_json()
    nodes = values.get('nodes')
    if nodes is None:
        return "Error: Please supply a valid list of nodes", 400

    for node in nodes:
        blockchain.register_node(node)

    response = {
        'message': 'New nodes have been added',
        'total_nodes': list(blockchain.nodes),
    }
    return jsonify(response), 201


# 解决冲突
@app.route('/nodes/resolve', methods=['GET'])
def consensus():
    replaced = blockchain.resolve_conflicts()

    if replaced:
        response = {
            'message': 'Our chain was replaced',
            'new_chain': blockchain.chain
        }
    else:
        response = {
            'message': 'Our chain is authoritative',
            'chain': blockchain.chain
        }

    return jsonify(response), 200


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

类 BlockChain分析:

构造函数：

• 创建一个变量nodes来存储所有的节点(保证节点之间互不相同)
• 创建一个变量chain来存储链
• 调用new_block函数创建创世块(设置初始hash值(创世块的previous hash), 检验值设置为100)

hash函数(static method):

• 将整个块的转成一个string,，然后再通过这个string生成hash值，并转成16进制
• 值得称赞的是，这里要确保通过json将dict转成string的过程中，需要保证keys的顺序。只有这样，才能确保整个hash映射到整个块的时候，得到的结果具有唯一性

last_block函数(通过@property操作符变成了一个属性)

• 会返回这个blockChain中最后一个块

valid_proof证明函数

• 传进来的两个检验值，一个是last_proof 还有一个就是proof。
• 在直接放在一起之后，通过哈希映射之中的sha256映射(再转16进制)
• 最后，通过判断上面得到的最终的哈希值来判断前4位是不是都是0
• 如果4个0开头，那么就是合法，否者就是不合法的

proof_of_work函数

• 通过传进来的那个函数中的参数(也就是前一个的proof值)
• 通过循环来逐步找到对应的当前proof使得上面的valid_proof函数返回的是一个true值

reister_node()函数

• 传进来的参数为address,表示地址。
• 这个参数必须是网页url，或者是对应的ip地址。
• 经过解析之后，节点的命名就是一个ip地址或者是网页地址（网络层面上跟ip地址等价）

valid_chain()函数

• 这里会传进来一个chain 可以理解为一个列表之类的可遍历的对象。
• 然后判断后一个块的previous_hash是不是真的就是前一个块做了hash的结果
• 同时也需要判断，这个检验值是否合法
• 直到这些都满足之后，才算是ok的

new_block函数：

• 创建一个新的块。语言层面上，其实就是一个字典。每个块存储的交易都是整个类一开始就公有的
• index设置为链长度+1
• ‘previous_hash’:previous_hash or self.hash(self.chain[-1]) 这个地方有点意思。
• 如果是创世块，这里就会直接得到对应的结果

ressolve_conflicts函数：

• 先循环检验每个节点。来进行判断
• 要求子节点存储的长度要小于总长度
• 要求子节点存储的链也必须是合法的
• 如果有合法的，并且子节点上的链长度更长那就复制给main服务器
• 如果发生过改变，就返回True
• else return false