本文参考“深入浅出区块链”的一篇文章,它翻译自Learn Blockchains by Building One

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

class Blockchain(object):
    def __init__(self):
        # 保存网络上的所有节点信息,用set来储存节点,这是一种避免重复添加节点的简单方法
        self.nodes = set()

        # 保存当前节点的区块链
        self.chain = []
        # 保存当前收到的所有交易
        self.current_transactions = []
        # Create the genesis block
        self.new_block(proof = 100, previous_hash = 1)
    
    def new_block(self, proof, previous_hash = None):
        """
        生成新块
        :param proof: <int> The proof given by the Proof of Work algorithm
        :param previous_hash: (Optional) <str> Hash of previous Block
        :return: <dict> New Block
        """
        # Creates a new Block and adds it to the chain
        block = {
            'index': len(self.chain) + 1,
            'timestamp': time(),
            'transactions': self.current_transactions,
            'proof': proof,
            'previous_hash': previous_hash or self.hash(self.chain[-1]),
        }

    # Reset the current list of transactions
    self.current_transactions = []

    self.chain.append(block)
    return block

    # Adds a new transaction to the list of transactions
    def new_transaction(self, sender, recipient, amount):
        self.current_transactions.append({
        'sender': sender,
        'recipient': recipient,
        'amount': amount,
    })
        # 返回该记录将被添加到的区块(下一个待挖掘的区块)的索引
        # 等下在用户提交交易时会有用。
        return self.last_block['index'] + 1


    @staticmethod
    def hash(block):
        # Hashes a Block
        """
        生成块的 SHA-256 hash值
        :param block:  Block
        :return: 
        """

        # We must make sure that the Dictionary is Ordered, 
        # or we'll have inconsistent hashes
        block_string = json.dumps(block, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()

    @property
    def last_block(self):
        # Returns the last Block in the chain
        return self.chain[-1]

    # 工作量证明
    def proof_of_work(self, last_proof):
        """
        简单的工作量证明:
         - 查找一个 p' 使得 hash(pp') 以4个0开头
         - p 是上一个块的证明,  p' 是当前的证明
        :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):
        """
        验证证明: 是否hash(last_proof, proof)以4个0开头?
        :param last_proof:  Previous Proof
        :param proof:  Current Proof
        :return:  True if correct, False if not.
        """

        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

    # 以下为“多节点共识”相关的方法
    def register_node(self, address):
        """
        Add a new node to the list of nodes
        :param address:  Address of node. Eg. 'http://192.168.0.5:5000'
        :return: None
        """

        parsed_url = urlparse(address)
        self.nodes.add(parsed_url.netloc)

    # 验证区块链是否有效:1. 子父区块的hash值是否一致; 
    # 2. 每个区块的工作量证明是否正确
    def valid_chain(self, chain):
        """
        Determine if a given blockchain is valid
        :param chain:  A blockchain
        :return:  True if valid, False if not
        """

        # 上一个区块
        last_block = chain[0]
        # 当前待验证区块的下标
        current_index = 1

        while current_index < len(chain):
            block = chain[current_index]
            print(f'{last_block}')
            print(f'{block}')
            print("\n-----------\n")
            # Check that the hash of the block is correct
            if block['previous_hash'] != self.hash(last_block):
                return False

            # Check that the Proof of Work is correct
            if not self.valid_proof(last_block['proof'], block['proof']):
                return False

            last_block = block
            current_index += 1

        return True

    # 解决冲突不同节点之间的冲突,实现一致性:
    # 查询网络上其他节点的区块链,在验证区块链有效的前提下,判断有没有更长的区块链,
    # 如果有,则将当前节点的区块链替换成新的更长的区块链
    def resolve_conflicts(self):
        """
        共识算法解决冲突
        使用网络中最长的链.
        :return:  True 如果链被取代, 否则为False
        """

        neighbours = self.nodes
        new_chain = None

        # We're only looking for chains longer than ours
        max_length = len(self.chain)

        # Grab and verify the chains from all the nodes in our network
        for node in neighbours:
            response = requests.get(f'http://{node}/chain')

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

                # Check if the length is longer and the chain is valid
                if length > max_length and self.valid_chain(chain):
                    max_length = length

                    # 这里是直接其他节点上更长的区块链赋值给当前节点。
                    # 当区块链的数据非常大时,这个地方肯定还需要再优化
                    new_chain = chain

        # Replace our chain if we discovered a new, 
        # valid chain longer than ours
        if new_chain:
            self.chain = new_chain
            return True

        return False

#----------class Blockchain definition end --------------

# Instantiate our Node
app = Flask(__name__)

# Generate a globally unique address for this node
node_identifier = str(uuid4()).replace('-', '')

# Instantiate the Blockchain
blockchain = Blockchain()


@app.route('/mine', methods=['GET'])
def mine():
    # 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)

    # 给工作量证明的节点提供奖励.
    # 发送者为 "0" 表明是新挖出的币
    blockchain.new_transaction(
        sender="0",
        recipient=node_identifier,
        amount=1,
    )

    # Forge the new Block by adding it to the chain
    block = blockchain.new_block(proof)

    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():
    values = request.get_json()

    # Check that the required fields are in the POST'ed data
    required = ['sender', 'recipient', 'amount']
    if not all(k in values for k in required):
        return 'Missing values', 400

    # Create a new Transaction
    index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])

    response = {'message': f'Transaction will be added to Block {index}'}
    return jsonify(response), 201

#返回当前内存池中所有待入块的交易
@app.route('/transactions/all', methods=['GET'])
def all_transactions():
    return jsonify(blockchain.current_transactions), 201

@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        'chain': blockchain.chain,
        'length': len(blockchain.chain),
    }
    return jsonify(response), 200

# 对外提供调用接口,向当前节点注册一个新节点,POST方式提交,Content-Type设置成
# application/json, body中的参数类似如下:
"""
{
    "nodes":["http://127.0.0.1:5001"]
}
"""
@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)