微信号:bjsxt-java

介绍:北京尚学堂科技有限公司是一家从事JAVA、大数据、Android、ios、web前端开发、培训、咨询为一体的软件公司.公司由海外留学人员和国内IT精英人士创建,主要成员均拥有硕士以上学位,毕业于国内著名大学如:清华大...

如何用 Python 撸一个区块链

2018-05-16 07:05 尚学堂


尚学堂
实战化教学领导品牌

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

但是理解区块链并非易事,至少对于我来说是如此。晦涩难懂的视频、漏洞百出的教程以及示例的匮乏令我倍受挫折。

我喜欢在实践中学习,通过写代码来学习技术会掌握得更牢固。如果你也这样做,那么读完本文,你将获得一个可用的区块链以及对区块链的深刻理解。

开始之前...

首先你需要知道区块链是由被称为区块的记录构成的不可变的、有序的链式结构,这些记录可以是交易、文件或任何你想要的数据,最重要的是它们是通过 Hash 连接起来的。

如果你不了解 Hash,这里有个例子

其次,你需要安装 Python3.6+,Flask,Request

 
           
  1. pip install Flask==0.12.2 requests==2.18.4

同时你还需要一个 HTTP 客户端,比如 Postman,cURL 或任何其它客户端。

最终的源代码在这里:

第一步: 打造一个 Blockchain

新建一个文件 blockchain.py,本文所有的代码都写在这一个文件中。首先创建一个 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

一个区块有五个基本属性:index,timestamp(in Unix time),transaction 列表,工作量证明(稍后解释)以及前一个区块的 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 都会变得不正确。不理解?慢慢消化~

我们需要一个向区块添加交易的方法:

 
           
  1. class Blockchain(object):

  2.    ...

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

  4.        """

  5.        Creates a new transaction to go into the next mined Block

  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

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

当 Blockchain 实例化后,我们需要创建一个初始的区块(创世块),并且给它预设一个工作量证明。

除了添加创世块的代码,我们还需要补充 newblock(), newtransaction() 和 hash() 方法:

 
           
  1. import hashlib

  2. import json

  3. from time import time

  4. class Blockchain(object):

  5.    def __init__(self):

  6.        self.current_transactions = []

  7.        self.chain = []

  8.        # Create the genesis block

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

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

  11.        block = {

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

  13.            'timestamp': time(),

  14.            'transactions': self.current_transactions,

  15.            'proof': proof,

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

  17.        }

  18.        # Reset the current list of transactions

  19.        self.current_transactions = []

  20.        self.chain.append(block)

  21.        return block

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

  23.        self.current_transactions.append({

  24.            'sender': sender,

  25.            'recipient': recipient,

  26.            'amount': amount,

  27.        })

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

  29.    @property

  30.    def last_block(self):

  31.        return self.chain[-1]

  32.    @staticmethod

  33.    def hash(block):

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

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

上面的代码应该很直观,我们基本上有了区块链的雏形。但此时你肯定很想知道一个区块究竟是怎样被创建或挖掘出来的。

新的区块来自工作量证明(PoW)算法。PoW 的目标是计算出一个符合特定条件的数字,这个数字对于所有人而言必须在计算上非常困难,但易于验证。这就是工作量证明的核心思想。

举个例子:

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

 
           
  1. from hashlib import sha256

  2. x = 5

  3. y = 0  # We don't know what y should be yet...

  4. while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":

  5.    y += 1

  6. print(f'The solution is y = {y}')

结果是 y = 21 // hash(5 * 21) = 1253e9373e...5e3600155e860

在比特币中,工作量证明算法被称为 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 proof_of_work(self, last_proof):

  8.        proof = 0

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

  10.            proof += 1

  11.        return proof

  12.    @staticmethod

  13.    def valid_proof(last_proof, proof):

  14.        guess = f'{last_proof}{proof}'.encode()

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

  16.        return guess_hash[:4] == "0000"

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

我们的 Blockchain 基本已经完成了,接下来我们将使用 HTTP requests 来与之交互。

第二步:作为 API 的 Blockchain

我们将使用 Flask 框架,它十分轻量并且很容易将网络请求映射到 Python 函数。

我们将创建三个接口:

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

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

  3. /chain 返回整个区块链

我们的服务器将扮演区块链网络中的一个节点。我们先添加一些常规代码:

 
           
  1. import hashlib

  2. import json

  3. from textwrap import dedent

  4. from time import time

  5. from uuid import uuid4

  6. from flask import Flask, jsonify, request

  7. class Blockchain(object):

  8.    ...

  9. # Instantiate our Node

  10. app = Flask(__name__)

  11. # Generate a globally unique address for this node

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

  13. # Instantiate the Blockchain

  14. blockchain = Blockchain()

  15. @app.route('/mine', methods=['GET'])

  16. def mine():

  17.    return "We'll mine a new Block"

  18. @app.route('/transactions/new', methods=['POST'])

  19. def new_transaction():

  20.    return "We'll add a new transaction"

  21. @app.route('/chain', methods=['GET'])

  22. def full_chain():

  23.    response = {

  24.        'chain': blockchain.chain,

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

  26.    }

  27.    return jsonify(response), 200

  28. if __name__ == '__main__':

  29.    app.run(host='127.0.0.1', port=5000)

这是用户发起交易时发送到服务器的请求:

 
           
  1. {

  2.  "sender": "my address",

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

  4.  "amount": 5

  5. }

我们已经有了向区块添加交易的方法,因此剩下的部分就很简单了:

 
           
  1. @app.route('/transactions/new', methods=['POST'])

  2. def new_transaction():

  3.    values = request.get_json()

  4.    # Check that the required fields are in the POST'ed data

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

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

  7.        return 'Missing values', 400

  8.    # Create a new Transaction

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

  10.    response = {'message': f'Transaction will be added to Block {index}'}

  11.    return jsonify(response), 201

挖掘端正是奇迹发生的地方,它只做三件事:计算 PoW;通过新增一个交易授予矿工一定数量的比特币;构造新的区块并将其添加到区块链中。

 
           
  1. @app.route('/mine', methods=['GET'])

  2. def mine():

  3.    # We run the proof of work algorithm to get the next proof...

  4.    last_block = blockchain.last_block

  5.    last_proof = last_block['proof']

  6.    proof = blockchain.proof_of_work(last_proof)

  7.    # We must receive a reward for finding the proof.

  8.    # The sender is "0" to signify that this node has mined a new coin.

  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.    return jsonify(response), 200

需注意交易的接收者是我们自己的服务器节点,目前我们做的大部分事情都只是围绕 Blockchain 类进行交互。到此,我们的区块链就算完成了。

第三步:交互演示

使用 Postman 演示,略。

第四步:一致性

这真的很棒,我们已经有了一个基本的区块链可以添加交易和挖矿。但是,整个区块链系统必须是分布式的。既然是分布式的,那么我们究竟拿什么保证所有节点运行在同一条链上呢?这就是一致性问题,我们要想在网络中添加新的节点,就必须实现保证一致性的算法。

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

 
           
  1. 1. /nodes/register 接收以 URL 的形式表示的新节点的列表

  2. 2. /nodes/resolve 用于执行一致性算法,用于解决任何冲突,确保节点拥有正确的链

  3. ...

  4. from urllib.parse import urlparse

  5. ...

  6. class Blockchain(object):

  7.    def __init__(self):

  8.        ...

  9.        self.nodes = set()

  10.        ...

  11.    def register_node(self, address):

  12.        parsed_url = urlparse(address)

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

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

前面提到的冲突是指不同的节点拥有的链存在差异,要解决这个问题,我们规定最长的合规的链就是最有效的链,换句话说,只有最长且合规的链才是实际存在的链。

让我们再添加两个方法,一个用于添加相邻节点,另一个用于解决冲突。

 
           
  1. ...

  2. import requests

  3. class Blockchain(object)

  4.    ...

  5.    def valid_chain(self, chain):

  6.        last_block = chain[0]

  7.        current_index = 1

  8.        while current_index < len(chain):

  9.            block = chain[current_index]

  10.            print(f'{last_block}')

  11.            print(f'{block}')

  12.            print("-----------")

  13.            # Check that the hash of the block is correct

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

  15.                return False

  16.            # Check that the Proof of Work is correct

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

  18.                return False

  19.            last_block = block

  20.            current_index += 1

  21.        return True

  22.    def resolve_conflicts(self):

  23.        neighbours = self.nodes

  24.        new_chain = None

  25.        # We're only looking for chains longer than ours

  26.        max_length = len(self.chain)

  27.        # Grab and verify the chains from all the nodes in our network

  28.        for node in neighbours:

  29.            response = requests.get(f'http://{node}/chain')

  30.            if response.status_code == 200:

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

  32.                chain = response.json()['chain']

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

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

  35.                    max_length = length

  36.                    new_chain = chain

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

  38.        if new_chain:

  39.            self.chain = new_chain

  40.            return True

  41.        return False

现在你可以新开一台机器,或者在本机上开启不同的网络接口来模拟多节点的网络,或者邀请一些朋友一起来测试你的区块链。

我希望本文能激励你创造更多新东西。我之所以对数字货币入迷,是因为我相信区块链会很快改变我们看待事物的方式,包括经济、政府、档案管理等。

阅读原文,了解详细信息

 
尚学堂 更多文章 全网60W下载量 高薪人工智能教程首度公开 5月10号 尚学堂专场招聘,看看都有哪6家公司 分享图片 人生最公平的3个时间:第一次是高考,第二次就是现在 小米招股书披露:员工平均年薪福利28万!
猜您喜欢 [第24期]Android技术资源每周精选 费劲洪荒之力的神总结:关于高可用系统的那些事 请别拿“死”人做文章 logistic回归:从生产到使用【上:使用篇】 用生产者消费者理解golang channel