devbox
程序代码艺术家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Python】实现一个简单的区块链系统_python 区块链

作者：程序代码艺术家 | 2023-12-30 21:16:55

赞

踩

python 区块链

本文章利用 Python 实现一个简单的功能较为完善的区块链系统（包括区块链结构、账户、钱包、转账），采用的共识机制是 POW。

一、区块与区块链结构

Block.py

  1. import hashlib
  2. from datetime import datetime
  3.  
  4.  
  5. class Block:
  6.     """
  7.         区块链结构：
  8.             prev_hash：      父区块哈希值
  9.             data：           区块内容
  10.             timestamp：      区块创建时间
  11.             hash：           区块哈希值
  12.     """
  13.     def __init__(self, data, prev_hash):
  14.         # 将传入的父区块哈希值和数据保存到变量中
  15.         self.prev_hash = prev_hash
  16.         self.data = data
  17.  
  18.         # 获得当前的时间
  19.         self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
  20.  
  21.         # 计算区块哈希值
  22.         # 获取哈希对象
  23.         message = hashlib.sha256()
  24.         # 先将数据内容转为字符串并进行编码，再将它们哈希
  25.         # 注意：update() 方法现在只接受 bytes 类型的数据，不接收 str 类型
  26.         message.update(str(self.prev_hash).encode('utf-8'))
  27.         message.update(str(self.prev_hash).encode('utf-8'))
  28.         message.update(str(self.prev_hash).encode('utf-8'))
  29.         # update() 更新 hash 对象，连续的调用该方法相当于连续的追加更新
  30.         # 返回字符串类型的消息摘要
  31.         self.hash = message.hexdigest()

 BlockChain.py

  1. from Block import Block
  2.  
  3.  
  4. class BlockChain:
  5.     """
  6.         区块链结构体
  7.             blocks：         包含区块的列表
  8.     """
  9.  
  10.     def __init__(self):
  11.         self.blocks = []
  12.  
  13.     def add_block(self, block):
  14.         """
  15.         添加区块
  16.         :param block:
  17.         :return:
  18.         """
  19.         self.blocks.append(block)
  20.  
  21.  
  22. # 新建区块
  23. genesis_block = Block(data="创世区块", prev_hash="")
  24. new_block1 = Block(data="张三转给李四一个比特币", prev_hash=genesis_block.hash)
  25. new_block2 = Block(data="张三转给王五三个比特币", prev_hash=genesis_block.hash)
  26.  
  27. # 新建一个区块链对象
  28. blockChain = BlockChain()
  29. # 将刚才新建的区块加入区块链
  30. blockChain.add_block(genesis_block)
  31. blockChain.add_block(new_block1)
  32. blockChain.add_block(new_block2)
  33.  
  34. # 打印区块链信息
  35. print("区块链包含区块个数为：%d\n" % len(blockChain.blocks))
  36. blockHeight = 0
  37. for block in blockChain.blocks:
  38.     print(f"本区块高度为：{blockHeight}")
  39.     print(f"父区块哈希：{block.prev_hash}")
  40.     print(f"区块内容：{block.data}")
  41.     print(f"区块哈希：{block.hash}")
  42.     print()
  43.     blockHeight += 1

 测试结果 

二、加入工作量证明（POW）

将工作量证明加入到 Block.py 中

  1. import hashlib
  2. from datetime import datetime
  3. from time import time
  4.  
  5.  
  6. class Block:
  7.     """
  8.         区块链结构：
  9.             prev_hash：      父区块哈希值
  10.             data：           区块内容
  11.             timestamp：      区块创建时间
  12.             hash：           区块哈希值
  13.             nonce：          随机数
  14.     """
  15.     def __init__(self, data, prev_hash):
  16.         # 将传入的父区块哈希值和数据保存到变量中
  17.         self.prev_hash = prev_hash
  18.         self.data = data
  19.  
  20.         # 获得当前的时间
  21.         self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
  22.  
  23.         # 设置随机数、哈希初始值为 None
  24.         self.nonce = None
  25.         self.hash = None
  26.  
  27.     # 类的 __repr__() 方法定义了实例化对象的输出信息
  28.     def __repr__(self):
  29.         return f"区块内容：{self.data}\n区块哈希值：{self.hash}"
  30.  
  31.  
  32. class ProofOfWork:
  33.     """
  34.         工作量证明：
  35.             block：          区块
  36.             difficulty：     难度值
  37.     """
  38.  
  39.     def __init__(self, block, difficult=5):
  40.         self.block = block
  41.  
  42.         # 定义出块难度，默认为 5，表示有效哈希值以 5 个零开头
  43.         self.difficulty = difficult
  44.  
  45.     def mine(self):
  46.         """
  47.         挖矿函数
  48.         :return:
  49.         """
  50.         i = 0
  51.         prefix = '0' * self.difficulty
  52.  
  53.         while True:
  54.             message = hashlib.sha256()
  55.             message.update(str(self.block.prev_hash).encode('utf-8'))
  56.             message.update(str(self.block.data).encode('utf-8'))
  57.             message.update(str(self.block.timestamp).encode('utf-8'))
  58.             message.update(str(i).encode('utf-8'))
  59.             # digest() 返回摘要，作为二进制数据字符串值
  60.             # hexdigest() 返回摘要，作为十六进制数据字符串值
  61.             digest = message.hexdigest()
  62.             # str.startswith(prefix) 检测字符串是否是以 prefix（字符串）开头，返回布尔值
  63.             if digest.startswith(prefix):
  64.                 # 幸运数字
  65.                 self.block.nonce = i
  66.                 # 区块哈希值为十六进制数据字符串摘要
  67.                 self.block.hash = digest
  68.                 return self.block
  69.             i += 1
  70.  
  71.     def validate(self):
  72.         """
  73.         验证有效性
  74.         :return:
  75.         """
  76.         message = hashlib.sha256()
  77.         message.update(str(self.block.prev_hash).encode('utf-8'))
  78.         message.update(str(self.block.data).encode('utf-8'))
  79.         message.update(str(self.block.timestamp).encode('utf-8'))
  80.         message.update(str(self.block.nonce).encode('utf-8'))
  81.         digest = message.hexdigest()
  82.  
  83.         prefix = '0' * self.difficulty
  84.         return digest.startswith(prefix)
  85.  
  86.  
  87. # ++++++++测试++++++++
  88. # 定义一个区块
  89. b = Block(data="测试", prev_hash="")
  90.  
  91. # 定义一个工作量证明
  92. w = ProofOfWork(b)
  93.  
  94. # 开始时间
  95. start_time = time()
  96. # 挖矿，并统计函数执行时间
  97. print("+++开始挖矿+++")
  98. valid_block = w.mine()
  99. # 结束时间
  100. end_time = time()
  101. print(f"挖矿花费时间：{end_time - start_time}秒")
  102.  
  103. # 验证区块
  104. print(f"区块哈希值是否符合规则：{w.validate()}")
  105. print(f"区块哈希值为：{b.hash}")

测试结果

更新 BlockChain.py

  1. from Block import Block, ProofOfWork
  2.  
  3.  
  4. class BlockChain:
  5.     """
  6.         区块链结构体
  7.             blocks：         包含区块的列表
  8.     """
  9.  
  10.     def __init__(self):
  11.         self.blocks = []
  12.  
  13.     def add_block(self, block):
  14.         """
  15.         添加区块
  16.         :param block:
  17.         :return:
  18.         """
  19.         self.blocks.append(block)
  20.  
  21.  
  22. # 新建一个区块链对象
  23. blockChain = BlockChain()
  24.  
  25. # 新建区块
  26. block1 = Block(data="创世区块", prev_hash="")
  27. w1 = ProofOfWork(block1)
  28. genesis_block = w1.mine()
  29. blockChain.add_block(genesis_block)
  30.  
  31. block2 = Block(data="张三转给李四一个比特币", prev_hash=genesis_block.hash)
  32. w2 = ProofOfWork(block2)
  33. block = w2.mine()
  34. blockChain.add_block(block)
  35.  
  36. block3 = Block(data="张三转给王五三个比特币", prev_hash=block.hash)
  37. w3 = ProofOfWork(block3)
  38. block = w3.mine()
  39. blockChain.add_block(block)
  40.  
  41. # 打印区块链信息
  42. print("区块链包含区块个数为：%d\n" % len(blockChain.blocks))
  43. blockHeight = 0
  44. for block in blockChain.blocks:
  45.     print(f"本区块高度为：{blockHeight}")
  46.     print(f"父区块哈希：{block.prev_hash}")
  47.     print(f"区块内容：{block.data}")
  48.     print(f"区块哈希：{block.hash}")
  49.     print()
  50.     blockHeight += 1

 测试结果

三、实现钱包、账户、交易功能

 实现钱包、账户、交易功能要先安装非对称加密算法库 ecdsa。如果网速慢，引用下面这个网站

-i https://pypi.tuna.tsinghua.edu.cn/simple

添加钱包、账户功能 Wallet.py

  1. import base64
  2. import binascii
  3. from hashlib import sha256
  4. # 导入椭圆曲线算法
  5. from ecdsa import SigningKey, SECP256k1, VerifyingKey
  6.  
  7.  
  8. class Wallet:
  9.     """
  10.         钱包
  11.     """
  12.  
  13.     def __init__(self):
  14.         """
  15.             钱包初始化时基于椭圆曲线生成一个唯一的秘钥对，代表区块链上一个唯一的账户
  16.         """
  17.         # 生成私钥
  18.         self._private_key = SigningKey.generate(curve=SECP256k1)
  19.         # 基于私钥生成公钥
  20.         self._public_key = self._private_key.get_verifying_key()
  21.  
  22.     @property
  23.     def address(self):
  24.         """
  25.             这里通过公钥生成地址
  26.         """
  27.         h = sha256(self._public_key.to_pem())
  28.         # 地址先由公钥进行哈希算法，再进行 Base64 计算而成
  29.         return base64.b64encode(h.digest())
  30.  
  31.     @property
  32.     def pubkey(self):
  33.         """
  34.             返回公钥字符串
  35.         """
  36.         return self._public_key.to_pem()
  37.  
  38.     def sign(self, message):
  39.         """
  40.             生成数字签名
  41.         """
  42.         h = sha256(message.encode('utf8'))
  43.         # 利用私钥生成签名
  44.         # 签名生成的是一串二进制字符串，为了便于查看，这里转换为 ASCII 字符串进行输出
  45.         return binascii.hexlify(self._private_key.sign(h.digest()))
  46.  
  47.  
  48. def verify_sign(pubkey, message, signature):
  49.     """
  50.         验证签名
  51.     """
  52.     verifier = VerifyingKey.from_pem(pubkey)
  53.     h = sha256(message.encode('utf8'))
  54.     return verifier.verify(binascii.unhexlify(signature), h.digest())

实现转账功能 Transaction.py

  1. import json
  2.  
  3.  
  4. class Transaction:
  5.     """
  6.         交易的结构
  7.     """
  8.  
  9.     def __init__(self, sender, recipient, amount):
  10.         """
  11.             初始化交易，设置交易的发送方、接收方和交易数量
  12.         """
  13.         # 交易发送者的公钥
  14.         self.pubkey = None
  15.         # 交易的数字签名
  16.         self.signature = None
  17.  
  18.         if isinstance(sender, bytes):
  19.             sender = sender.decode('utf-8')
  20.         self.sender = sender        # 发送方
  21.         if isinstance(recipient, bytes):
  22.             recipient = recipient.decode('utf-8')
  23.         self.recipient = recipient  # 接收方
  24.         self.amount = amount        # 交易数量
  25.  
  26.     def set_sign(self, signature, pubkey):
  27.         """
  28.             为了便于验证这个交易的可靠性，需要发送方输入他的公钥和签名
  29.         """
  30.         self.signature = signature  # 签名
  31.         self.pubkey = pubkey  # 发送方公钥
  32.  
  33.     def __repr__(self):
  34.         """
  35.             交易大致可分为两种，一是挖矿所得，而是转账交易
  36.             挖矿所得无发送方，以此进行区分显示不同内容
  37.         """
  38.         if self.sender:
  39.             s = f"从{self.sender}转自{self.recipient}{self.amount}个加密货币"
  40.         elif self.recipient:
  41.             s = f"{self.recipient}挖矿所得{self.amount}个加密货币"
  42.         else:
  43.             s = "error"
  44.         return s
  45.  
  46.  
  47. class TransactionEncoder(json.JSONEncoder):
  48.     """
  49.         定义Json的编码类，用来序列化Transaction
  50.     """
  51.     def default(self, obj):
  52.         if isinstance(obj, Transaction):
  53.             return obj.__dict__
  54.         else:
  55.             return json.JSONEncoder.default(self, obj)
  56.             # return super(TransactionEncoder, self).default(obj)

更新 Block.py

  1. import hashlib
  2. import json
  3. from datetime import datetime
  4. from Transaction import Transaction, TransactionEncoder
  5.  
  6.  
  7. class Block:
  8.     """
  9.         区块结构
  10.             prev_hash:      父区块哈希值
  11.             transactions:   交易对
  12.             timestamp:      区块创建时间
  13.             hash:           区块哈希值
  14.             Nonce:          随机数
  15.     """
  16.  
  17.     def __init__(self, transactions, prev_hash):
  18.         # 将传入的父哈希值和数据保存到类变量中
  19.         self.prev_hash = prev_hash
  20.         # 交易列表
  21.         self.transactions = transactions
  22.         # 获取当前时间
  23.         self.timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
  24.  
  25.         # 设置Nonce和哈希的初始值为None
  26.         self.nonce = None
  27.         self.hash = None
  28.  
  29.     # 类的 __repr__() 方法定义了实例化对象的输出信息
  30.     def __repr__(self):
  31.         return f"区块内容：{self.transactions}\n区块哈希值：{self.hash}"
  32.  
  33.  
  34. class ProofOfWork:
  35.     """
  36.         工作量证明
  37.             block：          区块
  38.             difficulty：     难度值
  39.     """
  40.  
  41.     def __init__(self, block, miner, difficult=5):
  42.         self.block = block
  43.         self.miner = miner
  44.  
  45.         # 定义工作量难度，默认为5，表示有效的哈希值以5个“0”开头
  46.         self.difficulty = difficult
  47.  
  48.         # 添加挖矿奖励
  49.         self.reward_amount = 1
  50.  
  51.     def mine(self):
  52.         """
  53.             挖矿函数
  54.         """
  55.         i = 0
  56.         prefix = '0' * self.difficulty
  57.  
  58.         # 设置挖矿自动生成交易信息，添加挖矿奖励
  59.         t = Transaction(
  60.             sender="",
  61.             recipient=self.miner.address,
  62.             amount=self.reward_amount,
  63.         )
  64.         sig = self.miner.sign(json.dumps(t, cls=TransactionEncoder))
  65.         t.set_sign(sig, self.miner.pubkey)
  66.         self.block.transactions.append(t)
  67.  
  68.         while True:
  69.             message = hashlib.sha256()
  70.             message.update(str(self.block.prev_hash).encode('utf-8'))
  71.             # 更新区块中的交易数据
  72.             # message.update(str(self.block.data).encode('utf-8'))
  73.             message.update(str(self.block.transactions).encode('utf-8'))
  74.             message.update(str(self.block.timestamp).encode('utf-8'))
  75.             message.update(str(i).encode("utf-8"))
  76.             digest = message.hexdigest()
  77.             if digest.startswith(prefix):
  78.                 self.block.nonce = i
  79.                 self.block.hash = digest
  80.                 return self.block
  81.             i += 1
  82.  
  83.     def validate(self):
  84.         """
  85.             验证有效性
  86.         """
  87.         message = hashlib.sha256()
  88.         message.update(str(self.block.prev_hash).encode('utf-8'))
  89.         # 更新区块中的交易数据
  90.         # message.update(str(self.block.data).encode('utf-8'))
  91.         message.update(json.dumps(self.block.transactions).encode('utf-8'))
  92.         message.update(str(self.block.timestamp).encode('utf-8'))
  93.         message.update(str(self.block.nonce).encode('utf-8'))
  94.         digest = message.hexdigest()
  95.  
  96.         prefix = '0' * self.difficulty
  97.         return digest.startswith(prefix)

更新 BlockChain.py

  1. from Block import Block, ProofOfWork
  2. from Transaction import Transaction
  3. from Wallet import Wallet, verify_sign
  4.  
  5.  
  6. class BlockChain:
  7.     """
  8.         区块链结构体
  9.             blocks:        包含的区块列表
  10.     """
  11.  
  12.     def __init__(self):
  13.         self.blocks = []
  14.  
  15.     def add_block(self, block):
  16.         """
  17.             添加区块
  18.         """
  19.         self.blocks.append(block)
  20.  
  21.     def print_list(self):
  22.         print(f"区块链包含个数为：{len(self.blocks)}")
  23.         for block in self.blocks:
  24.             height = 0
  25.             print(f"区块链高度为：{height}")
  26.             print(f"父区块为：{block.prev_hash}")
  27.             print(f"区块内容为：{block.transactions}")
  28.             print(f"区块哈希值为：{block.hash}")
  29.             height += 1
  30.             print()

为了方便我们对区块链进行操作，我们可以在 BlockChain.py 中补充一些方法

  1. # 传入用户和区块链，返回用户的“余额”
  2. def get_balance(user, blockchain):
  3.     balance = 0
  4.     for block in blockchain.blocks:
  5.         for t in block.transactions:
  6.             if t.sender == user.address.decode():
  7.                 balance -= t.amount
  8.             elif t.recipient == user.address.decode():
  9.                 balance += t.amount
  10.     return balance
  11.  
  12.  
  13. # user生成创世区块（新建区块链），并添加到区块链中
  14. def generate_genesis_block(user):
  15.     blockchain = BlockChain()
  16.     new_block = Block(transactions=[], prev_hash="")
  17.     w = ProofOfWork(new_block, user)
  18.     genesis_block = w.mine()
  19.     blockchain.add_block(genesis_block)
  20.     # 返回创世区块
  21.     return blockchain
  22.  
  23.  
  24. # 用户之间进行交易并记入交易列表
  25. def add_transaction(sender, recipient, amount):
  26.     # 新建交易
  27.     new_transaction = Transaction(
  28.         sender=sender.address,
  29.         recipient=recipient.address,
  30.         amount=amount
  31.     )
  32.     # 生成数字签名
  33.     sig = sender.sign(str(new_transaction))
  34.     # 传入付款方的公钥和签名
  35.     new_transaction.set_sign(sig, sender.pubkey)
  36.     return new_transaction
  37.  
  38.  
  39. # 验证交易，若验证成功则加入交易列表
  40. def verify_new_transaction(new_transaction, transactions):
  41.     if verify_sign(new_transaction.pubkey,
  42.                    str(new_transaction),
  43.                    new_transaction.signature
  44.                    ):
  45.         # 验证交易签名没问题，加入交易列表
  46.         print("交易验证成功")
  47.         transactions.append(new_transaction)
  48.     else:
  49.         print("交易验证失败")
  50.  
  51.  
  52. # 矿工将全部验证成功的交易列表打包出块
  53. def generate_block(miner, transactions, blockchain):
  54.     new_block = Block(transactions=transactions,
  55.                       prev_hash=blockchain.blocks[len(blockchain.blocks) - 1].hash)
  56.     print("生成新的区块...")
  57.     # 挖矿
  58.     w = ProofOfWork(new_block, miner)
  59.     block = w.mine()
  60.     print("将新区块添加到区块链中")
  61.     blockchain.add_block(block)

进行测试

  1. # 新建交易列表
  2. transactions = []
  3.  
  4. # 创建 3 个用户
  5. alice = Wallet()
  6. tom = Wallet()
  7. bob = Wallet()
  8.  
  9. print("alice创建创世区块...")
  10. blockchain = generate_genesis_block(alice)
  11. print()
  12.  
  13. print(f"alice 的余额为{get_balance(alice, blockchain)}个比特币")
  14. print(f"tom 的余额为{get_balance(tom, blockchain)}个比特币")
  15. print(f"bob 的余额为{get_balance(bob, blockchain)}个比特币")
  16. print()
  17.  
  18. # 打印区块链信息
  19. blockchain.print_list()
  20.  
  21. print("新增交易：alice 转账 0.5 比特币给 tom")
  22. nt = add_transaction(alice, tom, 0.5)
  23. print()
  24. verify_new_transaction(nt, transactions)
  25. print(f"矿工 bob 将全部验证成功的交易列表打包出块...")
  26. generate_block(bob, transactions, blockchain)
  27. print("添加完成\n")
  28.  
  29. # 打印区块链信息
  30. blockchain.print_list()

测试结果

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/blog/article/detail/36977
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号