用 Python 撸一个区块链

Python开发 ☉ 文来源：Python开发
2018-06-24 @ 哈希力量选录

归集: 首页 > 无人驾驶智能汽车 > 飞行汽车/无人机

人工摘要：首先你需要知道区块链是由被称为区块的记录构成的不可变的、有序的链式结构，这些记录可以是交易、文件或任何你想要的数据，最重要的是它们是通过 Hash 连接起来的。

相信你和我一样对数字货币的崛起感到新奇，并且想知道其背后的技术——区块链是怎样实现的。

但是理解区块链并非易事，至少对于我来说是如此。晦涩难懂的视频、漏洞百出的教程以及示例的匮乏令我倍受挫折。

我喜欢在实践中学习，通过写代码来学习技术会掌握得更牢固。如果你也这样做，那么读完本文，你将获得一个可用的区块链以及对区块链的深刻理解。

开始之前...

首先你需要知道区块链是由被称为区块的记录构成的不可变的、有序的链式结构，这些记录可以是交易、文件或任何你想要的数据，最重要的是它们是通过 Hash 连接起来的。

如果你不了解 Hash，这里有个例子

其次，你需要安装 Python3.6+，Flask，Request

pip install Flask==0.12.2 requests==2.18.4

同时你还需要一个 HTTP 客户端，比如 Postman，cURL 或任何其它客户端。

最终的源代码在这里：

第一步：打造一个 Blockchain

新建一个文件 blockchain.py，本文所有的代码都写在这一个文件中。首先创建一个 Blockchain 类，在构造函数中我们创建了两个列表，一个用于储存区块链，一个用于储存交易。

class Blockchain(object):
def __init__(self):
self.chain = []
self.current_transactions = []
def new_block(self):
# Creates a new Block and adds it to the chain
pass
def new_transaction(self):
# Adds a new transaction to the list of transactions
pass
@staticmethod
def hash(block):
# Hashes a Block
pass
@property
def last_block(self):
# Returns the last Block in the chain
pass

一个区块有五个基本属性：index，timestamp（in Unix time），transaction 列表，工作量证明（稍后解释）以及前一个区块的 Hash 值。

block = {
'index': 1,
'timestamp': 1506057125.900785,
'transactions': [
{
'sender': "8527147fe1f5426f9dd545de4b27ee00",
'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
'amount': 5,
}
],
'proof': 324984774000,
'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}

到这里，区块链的概念应该比较清楚了：每个新的区块都会包含上一个区块的 Hash 值。这一点非常关键，它是区块链不可变性的根本保障。如果攻击者破坏了前面的某个区块，那么后面所有区块的 Hash 都会变得不正确。不理解？慢慢消化~

我们需要一个向区块添加交易的方法：

class Blockchain(object):
...
def new_transaction(self, sender, recipient, amount):
"""
Creates a new transaction to go into the next mined Block
:param sender:Address of the Sender
:param recipient:Address of the Recipient
:param amount:Amount
:return:The index of the Block that will hold this transaction
"""
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
return self.last_block['index'] + 1

new_transaction() 方法向列表中添加一个交易记录，并返回该记录将被添加到的区块——下一个待挖掘的区块——的索引，稍后在用户提交交易时会有用。

当 Blockchain 实例化后，我们需要创建一个初始的区块（创世块），并且给它预设一个工作量证明。

除了添加创世块的代码，我们还需要补充 newblock(), newtransaction() 和 hash() 方法：

import hashlib
import json
from time import time
class Blockchain(object):
def __init__(self):
self.current_transactions = []
self.chain = []
# Create the genesis block
self.new_block(previous_hash=1, proof=100)
def new_block(self, proof, previous_hash=None):
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
def new_transaction(self, sender, recipient, amount):
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
return self.last_block['index'] + 1
@property
def last_block(self):
return self.chain[-1]
@staticmethod
def hash(block):
block_string = json.dumps(block, sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest()

上面的代码应该很直观，我们基本上有了区块链的雏形。但此时你肯定很想知道一个区块究竟是怎样被创建或挖掘出来的。

新的区块来自工作量证明（PoW）算法。PoW 的目标是计算出一个符合特定条件的数字，这个数字对于所有人而言必须在计算上非常困难，但易于验证。这就是工作量证明的核心思想。

举个例子：

假设一个整数 x 乘以另一个整数 y 的积的 Hash 值必须以 0 结尾，即 hash(x * y) = ac23dc...0。设 x = 5，求 y？

from hashlib import sha256
x = 5
y = 0 # We don't know what y should be yet...
while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":
y += 1
print(f'The solution is y = {y}')

结果是 y = 21 // hash(5 * 21) = 1253e9373e...5e3600155e860

在比特币中，工作量证明算法被称为 Hashcash，它和上面的问题很相似，只不过计算难度非常大。这就是矿工们为了争夺创建区块的权利而争相计算的问题。通常，计算难度与目标字符串需要满足的特定字符的数量成正比，矿工算出结果后，就会获得一定数量的比特币奖励（通过交易）。

网络要验证结果，当然非常容易。

让我们来实现一个 PoW 算法，和上面的例子非常相似，规则是：寻找一个数 p，使得它与前一个区块的 proof 拼接成的字符串的 Hash 值以 4 个零开头。

import hashlib
import json
from time import time
from uuid import uuid4
class Blockchain(object):
...
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 = f'{last_proof}{proof}'.encode()
guess_hash = hashlib.sha256(guess).hexdigest()
return guess_hash[:4] == "0000"

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

我们的 Blockchain 基本已经完成了，接下来我们将使用 HTTP requests 来与之交互。

第二步：作为 API 的 Blockchain

我们将使用 Flask 框架，它十分轻量并且很容易将网络请求映射到 Python 函数。

我们将创建三个接口：

/transactions/new 创建一个交易并添加到区块
/mine 告诉服务器去挖掘新的区块
/chain 返回整个区块链

我们的服务器将扮演区块链网络中的一个节点。我们先添加一些常规代码：

import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4
from flask import Flask, jsonify, request
class Blockchain(object):
...
# 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():
return "We'll mine a new Block"
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
return "We'll add a new transaction"
@app.route('/chain', methods=['GET'])
def full_chain():
response = {
'chain': blockchain.chain,
'length': len(blockchain.chain),
}
return jsonify(response), 200
if __name__ == '__main__':
app.run(host='127.0.0.1', port=5000)

这是用户发起交易时发送到服务器的请求：

{
"sender": "my address",
"recipient": "someone else's address",
"amount": 5
}

我们已经有了向区块添加交易的方法，因此剩下的部分就很简单了：

@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