近期的區塊鏈重回熱點,如果你想深入了解區塊鏈,那就來看一下本文,手把手教你構建一個自己的區塊鏈。

弄懂區塊鏈的最快方法-親自構建一個

看到這篇文章,說明您也是對加密貨幣的興起感興趣,想知道區塊鏈是如何工作的和其背后運行的技術原理。

但是想要搞懂區塊鏈并不容易。我在眾多的視頻中苦苦鉆研,跟隨著漏洞百出的教程,經歷著因區塊鏈相關案例太少而產生的挫敗感。

我喜歡從行動中學習。它迫使我從代碼層面處理問題,從而解決問題。如果您和我一樣做,那么在本指南的最后,您將擁有一個運行正常的區塊鏈,并對它們的工作原理有深入的了解。

上手準備

請記住,區塊鏈是一個不可變的、連續的記錄鏈,稱為塊。它們可以包含事務、文件或您喜歡的任何數據。但是重要的是,它們通過使用哈希而被鏈接在一起。

如果您不確定什么是哈希值,請參考這里。

教程面向的人群?

可以輕松地閱讀和編寫一些基本的Python,并且對HTTP請求的工作方式有所了解,因為本文將通過HTTP與區塊鏈進行交流。

需要準備什么?

確保已安裝 Python 3.6 +(以及pip)。您還需要安裝Flask和很棒的Requests庫:

pip install Flask==0.12.2 requests==2.18.4

您還需要HTTP客戶端,例如Postman或cURL。

源代碼可在此處獲得。

步驟1:構建一個區塊鏈

打開你最喜歡的文本編輯器或IDE,我個人喜歡  PyCharm。創建一個名為blockchain.py的新文件。我們將只使用一個文件,但是如果您有困惑了,可以隨時參考源代碼。

展示區塊鏈

我們將創建一個Blockchain class,它的構造函數會創建一個初始的空列表(用于存儲我們的區塊鏈),另一個用于存儲事務。這是腳本:

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

Blockchain class 的demo

我們的Blockchain class負責管理鏈。它將存儲事物,并具有一些將新塊添加到鏈中的輔助方法。讓我們來嘗試一些新的方法吧。

Block像什么?

每個Block都有以下的內容:

  • 一個索引,

  • 一個時間戳(Unix時間),

  • 一個交易列表,

  • 一個證明(稍后會有更多說明)

  • 前一個區塊的哈希值。

單個區塊示例:

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

在這一點上,鏈的概念應該很明顯--每個新區塊本身都包含前一個區塊的哈希值。這是至關重要的,因為這給予了區塊鏈的不可篡改性:如果攻擊者破壞了鏈中較早的區塊,則后續所有的區塊都將包含不正確的哈希值。

不知道你能理解嘛,請多花些時間去理解它—這是區塊鏈的核心思想。

添加事物到區塊中

我們需要一種將事物添加到區塊的方法。我們的new_transaction()方法有效,而且很簡單:

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被實例化,我們需要用一個genesis塊來播種它——一個沒有前處理的塊。還需要向我們的創世區塊添加一個“證明”,這是挖掘(或工作證明)的結果。稍后我們將詳細討論挖礦。

除了在構造函數中創建genesis塊,我們還將充實new_block()、new_transaction()和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):  
"""  
Create a new Block in the Blockchain  
:param proof: The proof given by the Proof of Work algorithm  
:param previous_hash: (Optional) Hash of previous Block  
:return: New Block  
"""  
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): 
"""  
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  
@property  
def last_block(self):  
return self.chain[-1]  
@staticmethod  
def hash(block):  
"""  
Creates a SHA-256 hash of a Block  
: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()

上面的內容應該很簡單—我添加了一些注釋和文檔字符串來幫助保持清楚明了。對區塊鏈的表示幾乎完成了。但此時,您一定想知道如何創建、鍛造或挖掘新的區塊。

了解工作量證明

工作算法(PoW)是在區塊鏈上創建或挖掘新區塊的方式。PoW的目標是發現可以解決問題的數字。從數字上來說,很難找到該數字,但是很容易被網絡上的任何人進行驗證。這是工作證明的核心思想。

我們將看一個非常簡單的示例來幫助理解。

讓我們決定某個整數X乘以另一個Y的哈希必須以0結尾。因此,對于這個簡化的示例,讓我們修復。在Python中實現:xy0hash(x * y) =  ac23dc...0x = 5

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。因為,產生的哈希值以0結尾:

hash(5 * 21)= 1253e9373e ... 5e3600155e860

在比特幣中,工作證明算法稱為Hashcash。而且與我們上面的示例并沒有太大不同。這是礦工為了創建一個新的塊而競相求解的算法。通常,難度由字符串中搜索的字符數決定。然后,通過在交易中獲得硬幣,礦工將借此獲得獎勵。

網絡能夠輕松驗證他們的解決方案。

實施基本的工作證明

讓我們為區塊鏈實現類似的算法。我們的規則將類似于上面的示例:

找出一個數字 p ,當該數字與上一個塊的解決方案進行哈希運算時,將產生一個帶有4個前導4個0的哈希。

import hashlib  
import json  
from time import time  
from uuid import uuid4  
class Blockchain(object):  
...  
def proof_of_work(self, last_proof):  
"""  
Simple Proof of Work Algorithm:  
- Find a number p' such that hash(pp') contains leading 4 zeroes, where p is the previous p'  
- p is the previous proof, and p' is the new 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):  
"""  
Validates the Proof: Does hash(last_proof, proof) contain 4 leading zeroes?  
: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"

要調整算法的難度,我們可以修改前導零的數量。但是4就足夠了。您會發現,添加單個前導零會極大地縮短尋找解決方案所需的時間。

我們的類快要完成了,我們已經準備好開始使用HTTP請求與其進行交互。

步驟2:我們的區塊鏈作為API

我們將使用Python  Flask框架。這是一個微框架,可輕松將端點映射到Python函數。這使我們可以使用HTTP請求通過web與區塊鏈進行通信。

我們將創建三種方法:

  • /transactions/new 創建一個新的交易塊。

  • /mine 告訴我們的服務器挖掘一個新塊。

  • /chain 返回完整的區塊鏈。

設置Flask

我們的“服務器”將在我們的區塊鏈網絡中形成單個節點。讓我們創建一個demo:

import hashlib  
import json  
from textwrap import dedent  
from time import time  
from uuid import uuid4  
from flask import Flask  
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='0.0.0.0', port=5000)

簡要說明:

  • 第15行:實例化我們的節點;Flask更多信息

  • 第18行:為節點創建一個隨機名稱。

  • 第21行:實例化Blockchain類。

  • 第24–26行:創建/mine端點,這是一個GET請求。

  • 第28–30行:創建/transactions/new端點,這是一個POST請求,因為我們將向它發送數據。

  • 第32–38行:創建/chain端點,該端點返回完整的區塊鏈。

  • 40-41行:在端口5000上運行服務器。


交易端點

這就是交易請求的樣子。這是用戶發送到服務器的內容:

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

由于我們已經有了用于將事務添加到塊中的類方法,因此其余操作很簡單。讓我們編寫添加事務的函數:

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()  
# 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

創建交易的方法

挖礦端點

我們的挖礦終點是奇跡發生的地方,這很容易上手。

它必須做三件事:

  1. 計算工作量證明

  2. 獎勵礦商(我們)通過增加一個交易給予我們1枚硬幣

  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():  
# 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)  
# We must receive a reward for finding the proof.  
# The sender is "0" to signify that this node has mined a new coin.  
blockchain.new_transaction(  
sender="0",  
recipient=node_identifier,  
amount=1,  
)  
# Forge the new Block by adding it to the chain  
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://127.0.0.1:5000/ (按CTRL + C退出)

讓我們嘗試通過向http://localhost:5000/mine:發出GET請求來挖掘一個塊:

使用郵遞員發出GET請求讓我們創建一個新的事務,通過發送POST請求到http://localhost:5000/transactions/new,其主體包含我們的事務結構:

使用郵遞員發出POST請求

如果您不使用Postman,可以使用cURL發出等效請求:

http://localhost:5000/chain:

{  
"chain": [  
{  
"index": 1,  
"previous_hash": 1,  
"proof": 100,  
"timestamp": 1506280650.770839,  
"transactions": []  
},  
{  
"index": 2,  
"previous_hash": "c099bc...bfb7",  
"proof": 35293,  
"timestamp": 1506280664.717925,  
"transactions": [  
{  
"amount": 1,  
"recipient": "8bbcb347e0634905b0cac7955bae152b",  
"sender": "0"  
}  
]  
},  
{  
"index": 3,  
"previous_hash": "eff91a...10f2",  
"proof": 35089,  
"timestamp": 1506280666.1086972,  
"transactions": [  
{  
"amount": 1,  
"recipient": "8bbcb347e0634905b0cac7955bae152b",  
"sender": "0"  
}  
]  
}  
],  
"length": 3  
}

步驟4:共識

我們目前已經擁有一個基本的區塊鏈,可以接受交易并允許我們挖掘新的區塊。但是區塊鏈的重點在于它們應該去中心化。而且,如果它們是去中心,我們如何確保它們都反映相同的鏈?這叫做共識問題,如果我們要在網絡中擁有多個節點,就必須實現共識算法。

注冊新節點

在實現共識算法之前,我們需要一種讓節點知道網絡上相鄰節點的方法。我們網絡上的每個節點都應保留網絡上其他節點的注冊表。

因此,我們將需要更多的端點:

  1. /nodes/register 接受URL形式的新節點列表。

  2. /nodes/resolve 實現我們的共識算法,該算法可以解決所有沖突-確保節點具有正確的鏈。

我們需要修改區塊鏈的構造函數,并提供一種注冊節點的方法:

...  
from urllib.parse import urlparse  
...  
class Blockchain(object):  
def __init__(self):  
...  
self.nodes = set()  
...  
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)

一種將相鄰節點添加到網絡的方法

請注意,我們使用了a set()來保存節點列表。這是一種廉價方法,它確保添加新節點是冪等,這意味著無論我們添加特定節點多少次,它都將只出現一次。

實施共識算法

如上所述,當一個節點與另一節點具有不同的鏈時會發生沖突。為了解決這個問題,我們規定最長的有效鏈是具有最高權威的。換句話說,網絡上最長的鏈是事實鏈。使用此算法,我們可以在網絡中的節點之間達成共識。

...  
import requests  
class Blockchain(object)  
...  
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):  
"""  
This is our Consensus Algorithm, it resolves conflicts  
by replacing our chain with the longest one in the network.  
:return: True if our chain was replaced, False if not  
"""  
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

第一種方法valid_chain()負責通過檢查每個塊并驗證哈希和檢驗鏈是否有效。

resolve_conflicts()是一種方法,它會檢查我們所有的相鄰節點,下載它們的鏈并使用上述方法驗證它們。如果找到有效鏈,其長度大于我們的長度,我們將替換它。

讓我們將兩個端點注冊到我們的API,一個端點用于添加相鄰節點,另一個端點用于解決沖突:

@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

此時,您可以根據需要使用其他計算機,并在網絡上啟動不同的節點。或使用同一臺計算機上的不同端口啟動進程。我在機器上的另一個端口上旋轉了另一個節點,并將其注冊到當前節點。因此,我有兩個節點:http://localhost:5000和http://localhost:5001。

注冊新節點

然后,我在節點2上挖到了一些新區塊,以確保鏈更長。之后,對GET  /nodes/resolve在節點1上進行了調用,在該節點上,該鏈被共識算法替換:

工作中的共識算法

目前為止已經接近成功;可以去找一些朋友一起幫助測試您的區塊鏈。

原文標題:Learn Blockchains by Building One,作者:Daniel van Flymen