python挖矿与共识算法的实现，以及单网络节点功能测试

以前几篇已经铺垫的足够了，挖矿原理，共识算法，节点同步都已经提到了，这里就综合起来做一个小小的综合实战。
代码实现如下：

import hashlib
import json
import time
from urllib.parse import urlparse
from uuid import uuid4
import requests
from flask import Flask, jsonify, request
from typing import Any, Dict, List, Optional  # 数据结构


class DadaCoinBlockChain:
    def __init__(self):
        self.current_transactions = []  # 交易列表
        self.chain = []  # 区块链
        self.nodes = set()  # 保存网络节点
        self.new_block(proof=100, preHash="1")  # 创世区块

    ##创建区块
    def new_block(self,
                  proof: int,  # 指定参数为int
                  preHash: Optional[str]  # 指定上一块的哈希数据类型为str，默认为None
                  ) -> Dict[str, Any]:  # 指定返回数据类型
        block = {
            "index": len(self.chain) + 1,  # 索引
            "timestamp": time.time(),  # 当前时间
            "transactions": self.current_transactions,
            "proof": proof,
            "preHash": preHash or self.hash(self.chain[-1])

        }
        self.current_transactions = []
        self.chain.append(block)

        return block

    @staticmethod
    def hash(block: Dict[str, Any]) -> str:
        block_str = json.dumps(block, sort_keys=True).encode("utf-8")
        return hashlib.sha256(block_str).hexdigest()

    def new_transaction(self, sender: str, receiver: str, amount: int) -> int:  # 创建交易
        transaction = {
            "sender": sender,
            "receiver": receiver,
            "amount": amount,
        }
        self.current_transactions.append(transaction)
        return self.last_block["index"] + 1  # 索引标记交易的数量

    @property
    def last_block(self) -> Dict[str, Any]:
        return self.chain[-1]

    def proof_of_work(self, last_proof: int) -> int:  # 工作量证明
        proof = 0
        while self.valid_proof(last_proof, proof) is False:
            proof += 1
        return proof


    @staticmethod
    def valid_proof(last_proof: int, proof: int) -> bool:  # 验证证明
        guess = f'{last_proof*proof}'.encode("utf-8")
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[-4:] == "1234"

    def register_node(self, addr: str) -> None:  # 加入网络的其他节点，用于更新
        now_url = urlparse(addr)
        self.nodes.add(now_url.netloc)  # 增加网络节点
        pass

    def valid_chain(self, chain: List[Dict[str, Any]]) -> bool:  # 区块链校验
        last_block = self.chain[0]
        current_index = 1
        while current_index < len(self.chain):
            block = self.chain[current_index]
            # 哈希校验
            if block["preHash"] != 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 resolve_conflict(self) -> bool:  # 同步区块链
        neighbours = self.nodes
        new_chain = None
        max_length = len(self.chain)
        for node in neighbours:
            response = requests.post(f'http://{node}/chain')
            if response.status_code == 200:
                chain = response.json()["chain"]
                length = response.json()["length"]
                if length > max_length and self.valid_chain(chain):
                    max_length = length
                    new_chain = chain
        if new_chain:
            self.chain = new_chain
            return True
        else:
            return False

接着做一个单节点的测试：

datacoin = DadaCoinBlockChain()  # 创建一个网络节点
node_id = str(uuid4()).replace("-", "")  # 生成钱包地址
print("当前节点钱包地址：", node_id)
app = Flask(__name__)  # 初始化


#首页
@app.route("/",methods=["POST"])
def index_page():
    return "欢迎来到大大币系统，你好小韭菜"

#获取区块链
@app.route("/chain",methods=["POST"])
def index_chain():
    response = {
        "chain":datacoin.chain,#区块链
        "length":len(datacoin.chain),
    }
    return jsonify(response),200

#创建新的交易
@app.route("/transaction",methods=["POST"])
def index_transaction():

    values = request.get_json(),
    required = ["sender","receiver","amount"]
    if not all(key in values for key in required):
        return "数据不完整",400
    index = datacoin.new_transaction(values["sender"],values["receiver"],values["amount"])
    response = {
        "message":f'交易加入到区块{index}',
    }


    return jsonify(response),200

#挖矿
@app.route("/mine",methods=["POST"])
def index_mine():
   last_block = datacoin.last_block
   last_proof = last_block["proof"]
   proof  = datacoin.proof_of_work(last_proof)#挖矿计算

   #系统奖励，挖矿产生交易
   datacoin.new_transaction(sender="0",receiver=node_id,amount=10)
   block = datacoin.new_block(proof,None) #增加一个区块
   response = {
       "message":"新的区块创建",
       "index":block["index"],
       "transactions":block["transactions"],
       "proof":block["proof"],
       "preHash":block["preHash"],
   }

   return jsonify(response), 200

if __name__ == "__main__":
    app.run("127.0.0.1",port=5000)

因为我设置成了post请求，所以这里借助postman进行测试
看下测试结果：
1.直接请求：http://127.0.0.1:5000

2，查看所有区块链：http://127.0.0.1:5000/chain，得到结果只有创世区块

3，开始挖矿：http://127.0.0.1:5000/mine,会得到新的区块，这里挖三次

4，再次查询所有区块链：

5，增加一次新的交易，http://127.0.0.1:5000/transaction,post json参数

 {
    "sender": "charles2",
    "receiver": "youyou2",
    "amount": 200
 }

然后执行3挖矿，争抢记账权，再看一下区块链
我这里多做了几次测试，可能数据跟上面不一样，但是效果是一样的:

终于顺利完成测试，这里有一点需要注意：新产生的交易记录，必须要挖矿成功，才会记录到区块链中，也就是所谓的争抢记账权,