来自：树下老男孩
链接：https://www.jianshu.com/p/6bc620f1bf9f
原文：https://hackernoon.com/learn-blockchains-by-building-one-117428612f46
区块链现在有多火看看比特币的价格也就知道了，不过作为一个有逼格的程序员，我们不应只关注到币的价值(为啥我没去买比特币，T-T)，而应该去关注技术的本质，这个号称“第四次工业革命”的区块链技术。不过很多人估计对这个技术不太了解，包括我自己。既然不懂不如自己动手撸一个，实践出真知。在翻阅文章的时候刚好找到了这篇文章，下面让我们自己动手搭建一个简单的区块链。
简单的说，区块链就是一个不可变、有序的链(chain)结构，链中保存着称之为块(block)的记录，这些记录可以是交易，文件或是任意你想要的数据。其中重要的是它们通过哈希链接在一起。
如果你不懂哈希，可以查阅《
揭秘区块链的核心技术之「哈希与加密算法 」
》，不过作为开发者应该都懂吧。。。
准备
这里我们会以python实现一个区块链，因此需要首先安装python，这里我是用的是python2.7版本,需要安装flask以及Requests库。
pip install Flask requests
同时还需要一个http客户端，比如postman或curl。
1、创建区块链
新建一个blockchain.py文件，我们这里只使用这一个文件。
区块链表示
我们首先创建一个Blockchain类，并且在构造函数中创建两个空的list，一个用于储存我们的区块链，另一个用于储存交易。
Blockchain类的定义如下：
class Blockchain(object):
def __init__(self):
self.chain = []
self.current_transactions = []
def new_block(self):
pass
def new_transaction(self):
pass
@staticmethod
def hash(block):
pass
@property
def last_block(self):】
pass
我们的Blockchain类用来管理链，它会存储交易信息，以及一些添加新的块到链中的辅助方法，让我们开始实现这些方法。
块(Block)长啥样？
每个块都包含如下属性：索引(index)，时间戳(Unix时间)，交易列表(transactions)，工作量证明(proof，稍后解释)以及前一个块的hash值，下面是一个区块的例子：
block = {
'index': 1,
'timestamp': 1506057125.900785,
'transactions': [
{
'sender': "8527147fe1f5426f9dd545de4b27ee00",
'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",
'amount': 5,
}
],
'proof': 324984774000,
'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
}
现在，链的概念应该很清楚了--每个新的区块都包含了上一个区块的hash值。这很重要，因为它保障了整个区块链的不可变性：如果攻击者毁坏了一个之前的块，那么后续所有的块的hash值都将错误。没有理解？停下来细想一下，这是区块链背后的核心思想
添加交易到区块
我们需要一个添加交易到区块的地方，实现一下new_transaction方法：
class Blockchain(object):
...
def new_transaction(self, sender, recipient, amount):
"""
添加一笔新的交易到transactions中
:param sender: 发送者地址
:param recipient: 接收者地址
:param amount: 数量
:return: 包含该交易记录的块的索引
"""
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
return self.last_block['index'] + 1
在new_transaction方法向列表中添加一个交易记录后，它返回该记录将被添加到的区块的索引--下一个待挖掘的区块。这在后面用户提交交易记录的时候会有用。
创建一个新的区块
当我们的Blockchain实例化之后，我们需要为它创建一个创世块(第一个区块，没有前区块，类似于链表的head)，并且给该创世块添加一个工作量证明(proof of work)，工作量证明是挖矿的结果。我们后面在来讨论挖矿。
除了在我们的构造函数中创建一个创世块之外，我们也要实现new_block(), new_transaction() 和 hash()方法：
import hashlib
import json
from time import time
class Blockchain(object):
def __init__(self):
self.chain = []
self.current_transactions = []
self.new_block(previous_hash=1, proof=100)
def new_block(self, proof, previous_hash=None):
"""
创建一个新的块，并添加到链中
:param proof: 证明
:param previous_hash: (Optional) 前一个块的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)):
"""
添加一笔新的交易到transactions中
:param sender: 发送者地址
:param recipient: 接收者地址
:param amount: 数量
:return: 包含该交易记录的块的索引
"""
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):
"""
创建区块的SHA-256哈希值
:param block: Block
:return:
"""
block_string = json.dumps(block, sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest()
上面的代码应该比较直观，我们差不多完成了区块链的表示了。不过你应该比较好奇新的区块是怎么创建或者挖出来的。
理解工作量证明(proof of work,pow)
工作量证明(POW),简单的说就是一份证明，该证明可以用来确认你做过一定量的工作。工作量证明的目标就是找到一个能解决一个问题的数字，这个数字不好找但是很容易证明(该数字就是问题的答案)，这就是工作量证明背后的核心思想(俗称挖矿)。
我们举一个简单的例子，方便理解：
假设有一个问题，一个整数x乘以整数y，对积做hash，hash值必须以0结尾，即hash(x * y) = ac23dc…0。我们假设X的值为5，求y的值大小？用Python实现如下：
from hashlib import sha256
x = 5
y = 0
while sha256(str(x*y).encode()).hexdigest()[-1] != "0":
y += 1
print('The solution is y = ' + str(y))
可以看到如下的结果：
在比特币中使用的工作量证明算法叫做Hashcash，它和我们上面的简单例子相差不大。矿工们为了获得能够创建新的区块权利，需要使用该算法参与计算竞争。通常，问题的难度取决于需要在字符串中查找的字符个数，矿工算出结果后，会获得相应的奖励币。
tips:比特币网络中任何一个节点，如果想生成一个新的区块并写入区块链，必须能够解出比特币网络给出的工作量证明问题。这道题关键的三个要素是工作量证明函数、区块及难度值。工作量证明函数是这道题的计算方法，区块决定了这道题的输入数据，难度值决定了这道题的所需要的计算量，谁最先解出问题，谁就能生成新的区块并写入区块链。
工作量证明简单实现
为我们的区块链实现一个相似的算法，规则跟上述的例子差不多：
找到一个数字p，该数字与前一个块的proof值的hash值以4个0开头
import
hashlib
import json
from time import time
from uuid import uuid4
class Blockchain(object):
...
def proof_of_work(self, last_proof):
"""
简单工作量证明(POW)算法:
- 找到一个数字p'，使得hash(pp')值的开头包含4个0, p是上一个块的proof, p'是新的proof
: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):
"""
验证Proof: hash(last_proof, proof)值开头是否包含4个0?
:param last_proof: 上一个Proof
:param proof: 当前Proof
:return:
"""
guess = (str(last_proof)+str(proof)).encode()
guess_hash = hashlib.sha256(guess).hexdigest()
return guess_hash[:4] == "0000"
为了调整算法的难度，我们可以修改需要匹配的0的个数。但4已经足够了，你会发现增加一个数字会大大增加计算的时间。
我们的Blockchain类差不多完成了，接下来可以开始用http请求进行交互了。
2、Blockchain作为api
我们将使用Python Flask框架，这是一个轻量级的Web应用框架，它能方便的将请求映射到 Python函数，这允许我们通过http请求跟区块链进行交互。
我们会创建3个方法：
/transactions/new 创建一个新的交易，并添加到区块中
/mine 告诉服务器服挖掘一个新的块
/chain 返回整个区块链
设置flask
我们的服务器会作为区块链网络中的一个节点，让我们添加一下代码：
import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4
from flask import Flask
class Blockchain(object):
...
app = Flask(__name__)
node_identifier = str(uuid4()).replace('-', '')
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='0.0.0.0', port=5000)
代码相对简单，就不做说明了。
交易请求
用户发给服务器的交易请求如下：
{
"sender": "my address"
,
"recipient": "someone else's address",
"amount": 5
}
我们在Blockchain类中已经定义了添加交易的方法，因此接下来的事情比较简单：
import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4
from flask import Flask, jsonify, request
...
@app.route('/transactions/new', methods=['POST'])
def new_transaction():
values = request.get_json()
required = ['sender', 'recipient', 'amount']
if not all(k in values for k in required):
return 'Missing values', 400
index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
response = {'message': f'Transaction will be added to Block {index}'}
return jsonify(response), 200
挖矿
挖矿是里面的神奇所在，而且很简单，只需要做如下三件事：
1 计算工作量证明
2 增加一个交易，授予矿工（自己）一个币
3 构造新区块并将其添加到链中
import hashlib
import json
from time import time
from uuid import uuid4
from flask import Flask, jsonify, request
...
@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
注意挖出来的新区块的接收者就是我们服务器节点的地址，我们做的大部分工作都只是调用Blockchain类的一些方法。到此，我们可以开始跟我们的区块链交互了。
3、与我们的区块链交互
你可以通过cURL或Postman去跟API交互。
启动服务器：
$ python blockchain.py
* Running on http:
让我们试着通过Get请求http://localhost:5000/mine来挖一个块：
mine.png
让我们通过POST请求http://localhost:5000/transactions/new创建一笔新的交易，post body包含交易的结构信息：
new.png
我重启服务器然后挖了两个块之后，现在总共有三个块(包含创世块)，我们可以通过http://localhost:5000/chain请求获取所有的块信息。
chain.png
4、一致性
我们已经有了一个可以接受交易以及挖矿的基础区块链。但是区块链系统应该是去中心化的，既然区块链是去中心化，我们该如何确保所有的节点都有同样的链呢？这就是一致性问题，如果想要在我们的区块链网络中运行多个节点，我们就需要实现一个一致性算法。
注册新节点
在实现一致性算法之前，我们需要找到一种方法让一个节点知道它相邻的节点。我们网络中的每个节点都需要保存一份其它节点的记录信息。因此让我们增加一些接口：
1、/nodes/register 接收以url表示的新节点列表
2、/nodes/resolve 实现一致性算法，解决冲突，确保每个节点都有正确的链信息
我们需要修改Blockchain的构造函数，添加一个注册节点的方法：
...
from urlparse import urlparse
...
class Blockchain(object)
