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

作者：Captain編譯

?

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

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

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

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

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

上手準備

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

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

教程面向的人群?

可以輕松地閱讀和編寫一些基本的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枚硬幣

將新的區塊上鏈? 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：共識

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

注冊新節點

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

因此，我們將需要更多的端點：

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

/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

閱讀目錄（置頂)(長期更新計算機領域知識）

閱讀目錄（置頂)(長期更新計算機領域知識）

閱讀目錄（置頂)(長期科技領域知識）

歌謠帶你看java面試題

?

總結

以上是生活随笔為你收集整理的第五十八期:从0到1 手把手教你建一个区块链的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。