用Django实现一个可运行的区块链应用

Posted 区块链与数字货币

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了用Django实现一个可运行的区块链应用相关的知识,希望对你有一定的参考价值。

区块链研究所VIP
最好的区块链研究社群

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

但是完全搞懂区块链并非易事,我喜欢在实践中学习,通过写代码来学习技术会掌握得更牢固。通过构建一个区块链可以加深对区块链的理解。

准备工作 本文要求读者对Python有基本的理解,能读写基本的Python,并且需要对HTTP请求有基本的了解。

我们知道区块链是由区块的记录构成的不可变、有序的链结构,记录可以是交易、文件或任何你想要的数据,重要的是它们是通过哈希值(hashes)链接起来的。

环境准备 环境准备,确保已经安装Python3.5, pip , django, requests,urllib,json,hashlib 安装方法:

 
   
   
 
  1. pip install django requests

同时还需要一个HTTP客户端,比如Postman,cURL或其它客户端,本文以Postman为例。

开始创建Blockchain 通过django-admin startproject block创建一个block的项目,在项目中创建一个demo项目django-admin startproject demo ,目录结构:

Blockchain类 在views中创建一个Blockchain类,在构造函数中创建了两个列表,一个用于储存区块链,一个用于储存交易。

以下是Blockchain类的框架:

 
   
   
 
  1. class Blockchain(object):

  2.    def __init__(self):

  3.        self.chain = []

  4.        self.current_transactions = []

  5.    def new_block(self):

  6.        # Creates a new Block and adds it to the chain

  7.        pass

  8.    def new_transaction(self):

  9.        # Adds a new transaction to the list of transactions

  10.        pass

  11.    @staticmethod

  12.    def hash(block):

  13.        # Hashes a Block

  14.        pass

  15.    @property

  16.    def last_block(self):

  17.        # Returns the last Block in the chain

  18.        pass

Blockchain类用来管理链条,它能存储交易,加入新块等,下面我们来进一步完善这些方法。

块结构 每个区块包含属性:索引(index),Unix时间戳(timestamp),交易列表(transactions),工作量证明(稍后解释)以及前一个区块的Hash值。

以下是一个区块的结构:

 
   
   
 
  1. block = {

  2.    'index': 1,

  3.    'timestamp': 1506057125.900785,

  4.    'transactions': [

  5.        {

  6.            'sender': "8527147fe1f5426f9dd545de4b27ee00",

  7.            'recipient': "a77f5cdfa2934df3954a5c7c7da5df1f",

  8.            'amount': 5,

  9.        }

  10.    ],

  11.    'proof': 324984774000,

  12.    'previous_hash': "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"

  13. }

到这里,区块链的概念就清楚了,每个新的区块都包含上一个区块的Hash,这是关键的一点,它保障了区块链不可变性。如果攻击者破坏了前面的某个区块,那么后面所有区块的Hash都会变得不正确。不理解的话,慢慢消化。

加入交易 接下来我们需要添加一个交易,来完善下new_transaction方法

 
   
   
 
  1. class Blockchain(object):

  2.    ...

  3.    def new_transaction(self, sender, recipient, amount):

  4.        """

  5.        生成新交易信息,信息将加入到下一个待挖的区块中

  6.        :param sender: <str> Address of the Sender

  7.        :param recipient: <str> Address of the Recipient

  8.        :param amount: <int> Amount

  9.        :return: <int> The index of the Block that will hold this transaction

  10.        """

  11.        self.current_transactions.append({

  12.            'sender': sender,

  13.            'recipient': recipient,

  14.            'amount': amount,

  15.        })

  16.        return self.last_block['index'] + 1

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

创建新块

当Blockchain实例化后,我们需要构造一个创世块(没有前区块的第一个区块),并且给它加上一个工作量证明。 每个区块都需要经过工作量证明,俗称挖矿,稍后会继续讲解。

为了构造创世块,我们还需要完善newblock(), newtransaction() 和hash() 方法:

 
   
   
 
  1. class Blockchain(object):

  2.    def __init__(self):

  3.        self.chain = []

  4.        self.current_transactions = []

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

  6.        self.nodes = set()

  7.    def new_block(self,proof,previous_hash= None):

  8.        block = {

  9.            'index': len(self.chain) + 1,

  10.            'timestamp': time(),

  11.            'transactions': self.current_transactions,

  12.            'proof':proof ,

  13.            'previous_hash': previous_hash or self.hash(self.chain[-1]),

  14.        }

  15.        self.current_transactions = []

  16.        self.chain.append(block)

  17.        return block

  18.    def new_transaction(self,sender,recipient,amount):

  19.        self.current_transactions.append({

  20.            'sender': sender,

  21.            'recipient': recipient,

  22.            'amount': amount,

  23.        })

  24.        return self.last_block['index']+1

  25.    @staticmethod

  26.    def hash(block):

  27.        block_string = json.dumps(block, sort_keys=True).encode()

  28.        return hashlib.sha256(block_string).hexdigest()

通过上面的代码和注释可以对区块链有直观的了解,接下来我们看看区块是怎么挖出来的。

理解工作量证明 新的区块依赖工作量证明算法(PoW)来构造。PoW的目标是找出一个符合特定条件的数字,这个数字很难计算出来,但容易验证。这就是工作量证明的核心思想。

为了方便理解,举个例子:

假设一个整数 x 乘以另一个整数 y 的积的 Hash 值必须以 0 结尾,即 hash(x * y) = ac23dc…0。设变量 x = 5,求 y 的值?

用Python实现如下:

 
   
   
 
  1. from hashlib import sha256

  2. x = 5

  3. y = 0

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

  5.      y += 1

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

  7. print(y)

在比特币中,使用称为Hashcash的工作量证明算法,它和上面的问题很类似。矿工们为了争夺创建区块的权利而争相计算结果。通常,计算难度与目标字符串需要满足的特定字符的数量成正比,矿工算出结果后,会获得比特币奖励。 当然,在网络上非常容易验证这个结果。

实现工作量证明 让我们来实现一个相似PoW算法,规则是:寻找一个数 p,使得它与前一个区块的 proof 拼接成的字符串的 Hash 值以 4 个零开头。

 
   
   
 
  1. import hashlib

  2. import json

  3. from time import time

  4. from uuid import uuid4

  5. class Blockchain(object):

  6.    ...

  7.    def last_block(self):

  8.        return self.chain[-1]

  9.    def proof_of_work(self, last_proof):

  10.        proof = 0

  11.        while self.valid_proof(last_proof, proof) is False:

  12.            proof += 1

  13.        return proof

  14.    @staticmethod

  15.    def valid_proof(last_proof, proof):

  16.        guess = str(last_proof*proof).encode()

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

  18.        return guess_hash[:5] == "00000"

衡量算法复杂度的办法是修改零开头的个数。使用4个来用于演示,你会发现多一个零都会大大增加计算出结果所需的时间。

现在Blockchain类基本已经完成了,接下来使用HTTP requests来进行交互。

Blockchain作为API接口 我们将使用Python django框架,这是一个轻量Web应用框架,它方便将网络请求映射到 Python函数,现在我们来让来试一下:

我们将创建三个接口:

/transactions/new 创建一个交易并添加到区块

/mine 告诉服务器去挖掘新的区块

/chain 返回整个区块链

创建节点 我们的“django web服务器”将扮演区块链网络中的一个节点。我们先添加一些框架代码:

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

  2. # Instantiate the Blockchain

  3. blockchain = Blockchain()

  4. def mine(request):

  5.    last_block = blockchain.last_block

  6.    last_proof = last_block['proof']

  7.    proof = blockchain.proof_of_work(last_proof)

  8.    print(proof)

  9.    blockchain.new_transaction(

  10.         sender="0",

  11.         recipient=node_identifier,

  12.         amount=1,

  13.     )

  14.     # Forge the new Block by adding it to the chain

  15.    block = blockchain.new_block(proof)

  16.    response = {

  17.         'message': "New Block Forged",

  18.         'index': block['index'],

  19.         'transactions': block['transactions'],

  20.         'proof': block['proof'],

  21.         'previous_hash': block['previous_hash'],

  22.    }

  23.    print(response)

  24.    return HttpResponse(json.dumps(response))

  25. def new_transaction(request):

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

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

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

  29.        return 'Missing values'

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

  31.    print(index)

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

  33.    return HttpResponse(json.dumps(response))

  34. def full_chain(request):

  35.    response = {

  36.        'chain': blockchain.chain,

  37.        'length': len(blockchain.chain),

  38.    }

  39.    return HttpResponse(json.dumps(response))

添加url路由节点:运行服务

 
   
   
 
  1. from demo import views

  2. urlpatterns = [

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

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

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

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

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

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

  9. ]

运行服务

 
   
   
 
  1. python manage.py runserver 127.0.0.1:8000

发送交易 发送到节点的交易数据,结构如下:

 
   
   
 
  1. {

  2. "sender": "my address",

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

  4. "amount": 5

  5. }

向服务添加一个交易

挖矿 挖矿正是神奇所在,它很简单,做了一下三件事:

1、计算工作量证明PoW

2、通过新增一个交易授予矿工(自己)一个币

3、构造新区块并将其添加到链中

 
   
   
 
  1.  def proof_of_work(self, last_proof):

  2.        proof = 0

  3.        while self.valid_proof(last_proof, proof) is False:

  4.            proof += 1

  5.        return proof

  6.    @staticmethod

  7.    def valid_proof(last_proof, proof):

  8.        guess = str(last_proof*proof).encode()

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

  10.        return guess_hash[:5] == "00000"

注意交易的接收者是我们自己的服务器节点,我们做的大部分工作都只是围绕Blockchain类方法进行交互。到此,我们的区块链就算完成了,我们来实际运行下

运行区块链 使用Postman 去和API进行交互

让我们通过请求 http://127.0.0.1:8000/mine 来进行挖矿

在挖了两次矿之后,就有3个块了,通过请求 http://localhost:8000/chain 可以得到所有的块信息。

 
   
   
 
  1. {

  2.    "chain": [

  3.        {

  4.            "transactions": [],

  5.            "proof": 100,

  6.            "timestamp": 1520314374.7261052,

  7.            "index": 1,

  8.            "previous_hash": 1

  9.        },

  10.        {

  11.            "transactions": [

  12.                {

  13.                    "sender": "0",

  14.                    "recipient": "27d4aae55b2848dcae52bc722d86e0c3",

  15.                    "amount": 1

  16.                }

  17.            ],

  18.            "proof": 1771087,

  19.            "timestamp": 1520314389.5019505,

  20.            "index": 2,

  21.            "previous_hash": "32fa73f48240160257e95fdf8422c6df734b5d7e8ceb69a41a5578643c1d36fb"

  22.        },

  23.        {

  24.            "transactions": [

  25.                {

  26.                    "sender": "d4ee26eee15148ee92c6cd394edd9705",

  27.                    "recipient": "5",

  28.                    "amount": 500

  29.                },

  30.                {

  31.                    "sender": "0",

  32.                    "recipient": "27d4aae55b2848dcae52bc722d86e0c3",

  33.                    "amount": 1

  34.                }

  35.            ],

  36.            "proof": 100,

  37.            "timestamp": 1520314592.4745598,

  38.            "index": 3,

  39.            "previous_hash": "e6b1be488e0ed20fe3ec51135e5fafb4dfffaa28a190967106a5dd3e89e4b3aa"

  40.        }

  41.    ],

  42.    "length": 3

  43. }

一致性(共识) 我们已经有了一个基本的区块链可以接受交易和挖矿。但是区块链系统应该是分布式的。既然是分布式的,那么我们究竟拿什么保证所有节点有同样的链呢?这就是一致性问题,我们要想在网络上有多个节点,就必须实现一个一致性的算法。

注册节点 在实现一致性算法之前,我们需要找到一种方式让一个节点知道它相邻的节点。每个节点都需要保存一份包含网络中其它节点的记录。因此让我们新增几个接口:

1、/register 接收URL形式的新节点列表

2、/resolve 执行一致性算法,解决任何冲突,确保节点拥有正确的链 我们修改下Blockchain的init函数并提供一个注册节点方法:

 
   
   
 
  1. from urllib.parse import urlparse

  2. ...

  3. class Blockchain(object):

  4.    def __init__(self):

  5.        ...

  6.        self.nodes = set()

  7.        ...

  8.    def register_node(self, address):

  9.        parsed_url = urlparse(address)

  10.        self.nodes.add(parsed_url.netloc)

我们用 set 来储存节点,这是一种避免重复添加节点的简单方法。

实现共识算法 前面提到,冲突是指不同的节点拥有不同的链,为了解决这个问题,规定最长的、有效的链才是最终的链,换句话说,网络中有效最长链才是实际的链。

我们使用一下的算法,来达到网络中的共识

 
   
   
 
  1. class Blockchain(object):

  2.    def __init__(self):

  3.        ...

  4.    def valid_chain(self, chain):

  5.        last_block = chain[0]

  6.        current_index = 1

  7.        while current_index < len(chain):

  8.            block = chain[current_index]

  9.            if block['previous_hash'] != self.hash(last_block):

  10.                return False

  11.            # Check that the Proof of Work is correct

  12.            if not self.valid_proof(last_block['proof'], block['proof']):

  13.                return False

  14.            last_block = block

  15.            current_index += 1

  16.        return True

  17.    def resolve_conflicts(self):

  18.        neighbours = self.nodes

  19.        new_chain = None

  20.        max_length = len(self.chain)

  21.        for node in neighbours:

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

  23.            if response.status_code == 200:

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

  25.                chain = json.loads(response)['chain']

  26.                # Check if the length is longer and the chain is valid

  27.                if length > max_length and self.valid_chain(chain):

  28.                    max_length = length

  29.                    new_chain = chain

  30.        # Replace our chain if we discovered a new, valid chain longer than ours

  31.        if new_chain:

  32.            self.chain = new_chain

  33.            return True

  34.        return False

第一个方法 valid_chain() 用来检查是否是有效链,遍历每个块验证hash和proof.

第2个方法 resolve_conflicts() 用来解决冲突,遍历所有的邻居节点,并用上一个方法检查链的有效性, 如果发现有效更长链,就替换掉自己的链

在url中添加两个路由,一个用来注册节点,一个用来解决冲突。

 
   
   
 
  1. from demo import views

  2. urlpatterns = [

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

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

  5. ]

你可以在不同的机器运行节点,或在一台机机开启不同的网络端口来模拟多节点的网络,这里在同一台机器开启不同的端口演示,在不同的终端运行一下命令,就启动了两个节点:http://127.0.0.1:8000和 http://127.0.0.1:8100

然后在节点8100节点上挖两个块,确保是更长的链,然后在节点8000节点上访问接口/resolve ,这时节点8100的链会通过共识算法被节点8000节点的链取代。

点击下方阅读原文,加入区块链研究社群

获取区块链技术学习资料,与同行互助学习交流

以上是关于用Django实现一个可运行的区块链应用的主要内容,如果未能解决你的问题,请参考以下文章

用Java代码实现区块链技术

用go语言撸一个简易版的区块链

用go语言撸一个简易版的区块链

用go语言撸一个简易版的区块链

《区块链编程》第五章

逻辑烧脑:python 区块链的简易实现