扣丁學堂區塊鏈培訓簡述用Django實現一個可運行的區塊鏈應用

時間 2019-12-06

標籤學堂區塊培訓簡述 django 實現一個運行應用欄目比特幣简体版

原文原文鏈接

對數字貨幣的崛起感到新奇的咱們，必定想知道其背後的技術——區塊鏈是怎樣實現的。本篇文章扣丁學堂區塊鏈培訓小編給讀者們分享一下用Django實現一個可運行的區塊鏈應用，感興趣的小夥伴就隨小編來了解一下吧。node

準備工做python

本文要求讀者對Python有基本的理解，能讀寫基本的Python，而且須要對HTTP請求有基本的瞭解。web

咱們知道區塊鏈是由區塊的記錄構成的不可變、有序的鏈結構，記錄能夠是交易、文件或任何你想要的數據，重要的是它們是經過哈希值（hashes）連接起來的。算法

環境準備django

環境準備，確保已經安裝Python3.5, pip , django, requests，urllib，json，hashlibjson

安裝方法：服務器

pip install django requests微信

同時還須要一個HTTP客戶端，好比Postman，cURL或其它客戶端，本文以Postman爲例。網絡

開始建立Blockchainapp

經過django-admin startproject block建立一個block的項目，在項目中建立一個demo項目django-admin startproject demo。

Blockchain類

在views中建立一個Blockchain類，在構造函數中建立了兩個列表，一個用於儲存區塊鏈，一個用於儲存交易。

如下是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

Blockchain類用來管理鏈條，它能存儲交易，加入新塊等，下面咱們來進一步完善這些方法。

塊結構

每一個區塊包含屬性：索引（index），Unix時間戳（timestamp），交易列表（transactions），工做量證實（稍後解釋）以及前一個區塊的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):

"""

生成新交易信息，信息將加入到下一個待挖的區塊中

:param sender: <str> Address of the Sender

:param recipient: <str> Address of the Recipient

:param amount: <int> Amount

:return: <int> 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

方法向列表中添加一個交易記錄，並返回該記錄將被添加到的區塊(下一個待挖掘的區塊)的索引，等下在用戶提交交易時會有用。

建立新塊

當Blockchain實例化後，咱們須要構造一個創世塊（沒有前區塊的第一個區塊），而且給它加上一個工做量證實。

每一個區塊都須要通過工做量證實，俗稱挖礦，稍後會繼續講解。

爲了構造創世塊，咱們還須要完善new_block(), new_transaction() 和hash() 方法：

class Blockchain(object):

def __init__(self):

self.chain = []

self.current_transactions = []

self.new_block(previous_hash=1, proof=100)

self.nodes = set()

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]),

}

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

@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 的值？

用Python實現以下：

from hashlib import sha256

x = 5

y = 0

while sha256(str(x*y).encode()).hexdigest()[:4] != "0000":

y += 1

print(y,sha256(str(x*y).encode()).hexdigest()[:4])

print(y)

在比特幣中，使用稱爲Hashcash的工做量證實算法，它和上面的問題很相似。礦工們爲了爭奪建立區塊的權利而爭相計算結果。一般，計算難度與目標字符串須要知足的特定字符的數量成正比，礦工算出結果後，會得到比特幣獎勵。

固然，在網絡上很是容易驗證這個結果。

實現工做量證實

讓咱們來實現一個類似PoW算法，規則是：尋找一個數 p，使得它與前一個區塊的 proof 拼接成的字符串的 Hash 值以 4 個零開頭。

import hashlib

import json

from time import time

from uuid import uuid4

class Blockchain(object):

...

def last_block(self):

return self.chain[-1]

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 = str(last_proof*proof).encode()

guess_hash = hashlib.sha256(guess).hexdigest()

return guess_hash[:5] == "00000"

衡量算法複雜度的辦法是修改零開頭的個數。使用4個來用於演示，你會發現多一個零都會大大增長計算出結果所需的時間。

如今Blockchain類基本已經完成了，接下來使用HTTP requests來進行交互。

Blockchain做爲API接口

咱們將使用Python django框架，這是一個輕量Web應用框架，它方便將網絡請求映射到 Python函數，如今咱們來讓來試一下：

咱們將建立三個接口：

/transactions/new 建立一個交易並添加到區塊

/mine 告訴服務器去挖掘新的區塊

/chain 返回整個區塊鏈

建立節點

咱們的「django web服務器」將扮演區塊鏈網絡中的一個節點。咱們先添加一些框架代碼：

node_identifier = str(uuid4()).replace('-', '')

Instantiate the Blockchain

blockchain = Blockchain()

def mine(request):

last_block = blockchain.last_block

last_proof = last_block['proof']

proof = blockchain.proof_of_work(last_proof)

print(proof)

blockchain.new_transaction(

sender="0",

recipient=node_identifier,

amount=1,

)

# Forge the new Block by adding it to the chain

block = blockchain.new_block(proof)

response = {

'message': "New Block Forged",

'index': block['index'],

'transactions': block['transactions'],

'proof': block['proof'],

'previous_hash': block['previous_hash'],

}

print(response)

return HttpResponse(json.dumps(response))

def new_transaction(request):

values = json.loads(request.body.decode('utf-8'))

required = ['sender', 'recipient', 'amount']

if not all(k in values for k in required):

return 'Missing values'

index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])

print(index)

response = {'message': 'Transaction will be added to Block %s'%index}

return HttpResponse(json.dumps(response))

def full_chain(request):

response = {

'chain': blockchain.chain,

'length': len(blockchain.chain),

}

return HttpResponse(json.dumps(response))

添加url路由節點：運行服務

from demo import views

urlpatterns = [

url(r'^admin/', admin.site.urls),

url(r'^mine', views.mine),

url(r'^transactions/new/', views.new_transaction),

url(r'^chain/', views.full_chain),

url(r'^register', views.register_nodes),

url(r'^resolve', views.consensus),

]

運行服務

python manage.py runserver 127.0.0.1:8000

發送交易

發送到節點的交易數據，結構以下：

{

"sender": "my address",

"recipient": "someone else's address",

"amount": 5

}

向服務添加一個交易

挖礦

挖礦正是神奇所在，它很簡單，作了一下三件事：

計算工做量證實PoW

經過新增一個交易授予礦工（本身）一個幣

構造新區塊並將其添加到鏈中

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 = str(last_proof*proof).encode()

guess_hash = hashlib.sha256(guess).hexdigest()

return guess_hash[:5] == "00000"

注意交易的接收者是咱們本身的服務器節點，咱們作的大部分工做都只是圍繞Blockchain類方法進行交互。到此，咱們的區塊鏈就算完成了，咱們來實際運行下。

運行區塊鏈

你可使用cURL 或Postman 去和API進行交互

在挖了兩次礦以後，就有3個塊了

{ "chain": [

{

  "transactions": [],

  "proof": 100,

  "timestamp": 1520314374.7261052,

  "index": 1,

  "previous_hash": 1

},

{

  "transactions": [

    {

      "sender": "0",

      "recipient": "27d4aae55b2848dcae52bc722d86e0c3",

      "amount": 1

    }

  ],

  "proof": 1771087,

  "timestamp": 1520314389.5019505,

  "index": 2,

  "previous_hash": "32fa73f48240160257e95fdf8422c6df734b5d7e8ceb69a41a5578643c1d36fb"

},

{

  "transactions": [

    {

      "sender": "d4ee26eee15148ee92c6cd394edd9705",

      "recipient": "5",

      "amount": 500

    },

    {

      "sender": "0",

      "recipient": "27d4aae55b2848dcae52bc722d86e0c3",

      "amount": 1

    }

  ],

  "proof": 100,

  "timestamp": 1520314592.4745598,

  "index": 3,

  "previous_hash": "e6b1be488e0ed20fe3ec51135e5fafb4dfffaa28a190967106a5dd3e89e4b3aa"

}

"length": 3

}

一致性（共識）

咱們已經有了一個基本的區塊鏈能夠接受交易和挖礦。可是區塊鏈系統應該是分佈式的。既然是分佈式的，那麼咱們究竟拿什麼保證全部節點有一樣的鏈呢？這就是一致性問題，咱們要想在網絡上有多個節點，就必須實現一個一致性的算法。

註冊節點

在實現一致性算法以前，咱們須要找到一種方式讓一個節點知道它相鄰的節點。每一個節點都須要保存一份包含網絡中其它節點的記錄。所以讓咱們新增幾個接口：

/register 接收URL形式的新節點列表

/resolve 執行一致性算法，解決任何衝突，確保節點擁有正確的鏈

咱們修改下Blockchain的init函數並提供一個註冊節點方法：

from urllib.parse import urlparse

...

class Blockchain(object):

def __init__(self):

...

self.nodes = set()

...

def register_node(self, address):

parsed_url = urlparse(address)

self.nodes.add(parsed_url.netloc)

咱們用 set 來儲存節點，這是一種避免重複添加節點的簡單方法。

實現共識算法

前面提到，衝突是指不一樣的節點擁有不一樣的鏈，爲了解決這個問題，規定最長的、有效的鏈纔是最終的鏈，換句話說，網絡中有效最長鏈纔是實際的鏈。

咱們使用一下的算法，來達到網絡中的共識

class Blockchain(object):

def __init__(self):

...

def valid_chain(self, chain):

last_block = chain[0]

current_index = 1

while current_index < len(chain):

  block = chain[current_index]

  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):

neighbours = self.nodes

new_chain = None

max_length = len(self.chain)

for node in neighbours:

  response = requests.get('http://%s/chain' %node)

  if response.status_code == 200:

    length = json.loads(response)['length']

    chain = json.loads(response)['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() 用來檢查是不是有效鏈，遍歷每一個塊驗證hash和proof.

第2個方法 resolve_conflicts() 用來解決衝突，遍歷全部的鄰居節點，並用上一個方法檢查鏈的有效性，若是發現有效更長鏈，就替換掉本身的鏈

在url中添加兩個路由，一個用來註冊節點，一個用來解決衝突。

from demo import views

urlpatterns = [

url(r'^register', views.register_nodes),

url(r'^resolve', views.consensus),

]

你能夠在不一樣的機器運行節點，或在一臺機機開啓不一樣的網絡端口來模擬多節點的網絡，這裏在同一臺機器開啓不一樣的端口演示，在不一樣的終端運行一下命令。

而後在節點8100節點上挖兩個塊，確保是更長的鏈，而後在節點8000節點上訪問接口/resolve ,這時節點8100的鏈會經過共識算法被節點8000節點的鏈取代。

想要了解更多關於區塊鏈方面內容的小夥伴，請關注扣丁學堂區塊鏈培訓官網、微信等平臺，扣丁學堂IT職業在線學習教育有專業的區塊鏈講師爲您指導，此外扣丁學堂老師精心推出的區塊鏈視頻教程定能讓你快速掌握區塊鏈從入門到精通開發實戰技能。