如何用 python 从 0 开始创建一个区块链? -买球官网平台

0顶
0踩

引用
作者:daniel van flymen  纽约区块链工程师
译者:熊丽兵 牛娃软件cto


在数字货币盛行的档口,比特币,这币那币到底值不值得信赖呢?也许你像很多人一样感到新奇,想接近它,但只因背后的区块链技术,阻断了向新领域尝试的步伐。不过,对于程序员来说,想真正搞懂比特币,搞懂区块链,可不是难题,因为他们能边玩边学,通过一行行pyhton代码,就能真正理解数字货币的底层秘密。能用这么有逼格的方式来学习区块链的,也只有程序员了。

准备工作

本文要求读者对python有基本的理解,能读写基本的python,并且需要对http请求有基本的了解。

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

如果你还不是很了解哈希,可以查看这篇文章。

环境准备

环境准备,确保已经安装python3.6 、pip、flask、requests。

安装方法:
pip install flask==0.12.2 requests==2.18.4

同时还需要一个http客户端,比如postman、curl或其它客户端。

参考源代码(原代码在我翻译的时候,无法运行,我fork了一份,修复了其中的错误,并添加了翻译,感谢star)。

开始创建blockchain

新建一个文件 blockchain.py,本文所有的代码都写在这一个文件中,可以随时参考源代码。

blockchain类

首先创建一个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都会变得不正确。不理解的话,慢慢消化,可参考{% post_link whatbc 区块链技术原理 %}。

加入交易

接下来我们需要添加一个交易,来完善下new_transaction方法:
class blockchain(object):
    ...
    def new_transaction(self, sender, recipient, amount):
        """
        生成新交易信息,信息将加入到下一个待挖的区块中
        :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

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

创建新块

当blockchain实例化后,我们需要构造一个创世块(没有前区块的第一个区块),并且给它加上一个工作量证明。

每个区块都需要经过工作量证明,俗称挖矿,稍后会继续讲解。

为了构造创世块,我们还需要完善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):
        """
        生成新块
        :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):
        """
        生成新交易信息,信息将加入到下一个待挖的区块中
        :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):
        """
        生成块的 sha-256 hash值
        :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 的积的 hash 值必须以 0 结尾,即 hash(x * y) = ac23dc...0。设变量 x = 5,求 y 的值?

用python实现如下:
from hashlib import sha256
x = 5
y = 0  # y未知
while sha256(f'{x*y}'.encode()).hexdigest()[-1] != "0":
    y  = 1
print(f'the solution is y = {y}')

结果是y=21,因为:
hash(5 * 21) = 1253e9373e...5e3600155e860

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

当然,在网络上非常容易验证这个结果。

实现工作量证明

让我们来实现一个相似pow算法,规则是:寻找一个数 p,使得它与前一个区块的 proof 拼接成的字符串的 hash 值以 4 个零开头。
import hashlib
import json
from time import time
from uuid import uuid4
class blockchain(object):
    ...
    def proof_of_work(self, last_proof):
        """
        简单的工作量证明:
         - 查找一个 p' 使得 hash(pp') 以4个0开头
         - p 是上一个块的证明,  p' 是当前的证明
        :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):
        """
        验证证明: 是否hash(last_proof, proof)以4个0开头?
        :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个来用于演示,你会发现多一个零都会大大增加计算出结果所需的时间。

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

blockchain作为api接口

我们将使用python flask框架,这是一个轻量web应用框架,它方便将网络请求映射到 python函数,现在我们来让blockchain运行在基于flask web上。

我们将创建三个接口:
  • /transactions/new 创建一个交易并添加到区块;
  • /mine 告诉服务器去挖掘新的区块;
  • /chain 返回整个区块链。
创建节点

我们的“flask服务器”将扮演区块链网络中的一个节点,我们先添加一些框架代码:
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行:创建一个节点;
第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

挖矿

挖矿正是神奇所在,它很简单,做了以下三件事:
  • 计算工作量证明pow;
  • 通过新增一个交易授予矿工(自己)一个币;
  • 构造新区块并将其添加到链中。
import hashlib
import json
from textwrap import dedent
from time import time
from uuid import uuid4
from flask import flask, jsonify, request
...
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)
    # 给工作量证明的节点提供奖励.
    # 发送者为 "0" 表明是新挖出的币
    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'],
    }
    return jsonify(response), 200

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

运行区块链

你可以使用curl或postman去和api进行交互。

启动server:
$ python blockchain.py
* runing on http://127.0.0.1:5000/ (press ctrl c to quit)

让我们通过请求 来进行挖矿:

通过post请求,添加一个新交易:

如果不是使用postman,则用以下的curl语句也是一样的:
$ curl -x post -h "content-type: application/json" -d '{
 "sender": "d4ee26eee15148ee92c6cd394edd974e",
 "recipient": "someone-other-address",
 "amount": 5
}' "http://localhost:5000/transactions/new"

在挖了两次矿之后,就有3个块了,通过请求 可以得到所有的块信息。
{
  "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
}

一致性(共识)

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

注册节点

在实现一致性算法之前,我们需要找到一种方式让一个节点知道它相邻的节点。每个节点都需要保存一份包含网络中其它节点的记录,因此让我们新增几个接口:
  • /nodes/register 接收url形式的新节点列表;
  • /nodes/resolve 执行一致性算法,解决任何冲突,确保节点拥有正确的链。

我们修改下blockchain的init函数并提供一个注册节点方法:
...
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)

我们用 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):
        """
        共识算法解决冲突
        使用网络中最长的链.
        :return:  true 如果链被取代, 否则为false
        """
        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() 用来检查是否是有效链,遍历每个块验证hash和proof。

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

让我们添加两个路由,一个用来注册节点,一个用来解决冲突。
@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。
pipenv run python blockchain.py
pipenv run python blockchain.py -p 5001


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

好啦,你可以邀请朋友们一起来测试你的区块链。

引用
作者简介:daniel van flymen,纽约区块链工程师。
译者简介:熊丽兵,牛娃软件cto,深入浅出区块链learnblockchain.cn博主,区块链大本营特邀专栏作者。擅长java/python/javascript语言,曾就职于创新工场(点心团队),猎豹移动,参与开发移动应用,如安卓优化大师、清理大师等。昵称tiny熊,区块链大本营特邀专栏作者,对底层公链,区块链技术落地有深入研究。
  • 大小: 155.3 kb
  • 大小: 104.5 kb
  • 大小: 103.5 kb
  • 大小: 73.5 kb
  • 大小: 98.9 kb
来自:
0
0
评论 共 0 条 请登录后发表评论

发表评论

您还没有登录,请您登录后再发表评论

相关推荐

  • 确保已经安装python3.6 ,pip,flask,requests,安装方法:同时还需要一个http客户端,比如postman,curl或其它客户端。参考https://github.com/xilibi2003/blockchain新建一个文件blockchain.py,本文所有的代码都写...

  • 不过,对于程序员来说,想真正搞懂比特币,搞懂区块链,可不是难题,因为他们能边玩边学,通过一行行pyhton代码,就能真正理解数字货币的底层秘密。能用这么有逼格的方式来学习区块链的,也只有程序员了。 ...

  • 转自:http://blog.csdn.net/blockchain_lemon/article/details/79395163在数字货币...不过,对于程序员来说,想真正搞懂比特币,搞懂区块链,可不是难题,因为他们能边玩边学,通过一行行pyhton代码,就能真正理解...

  • 本文通过 python 构建一个区块链可以加深对区块链的理解。准备工作本文要求读者对 python 有基本的理解,能读写基本的 python,并且需要对 http 请求有基本的了解。我们知道区块链是由区块的记录构成的不可变、有序...

  • github上提供了一个完整的样本应用程序代码,该应用程序完全是用python编写的。主要逻辑包含在views.py文件中。让我们一起分析一下该逻辑,以便真正全面了解区块链。python的基础编程知识flask微框架(用于创建...

  • 学习区块链最快的方式是自己创建一个,本文就跟随作者用python来创建一个区块链。

  •  类 ,他的构造函数创建了一个初始化的空列表(要存储我们的区块链),并且另一个存储交易。下面是我们这个类的实例: blockchain.py class blockchain(object): def __init__(self): self.chain = [] self....

  • 作者认为最快的学习区块链的方式是自己创建一个,本文就跟随作者用python来创建一个区块链。对数字货币的崛起感到新奇的我们,并且想知道其背后的技术——区块链是怎样实现的。但是完全搞懂区块链并非易事,我喜欢在...

  • 主要为大家详细介绍了python从零开始创建区块链的步骤,具有一定的参考价值,感兴趣的小伙伴们可以参考一下

  • 区块链python设置1.创建一个名为wallet的项目目录,并进入cd。 将hd-wallet派生工具克隆到此文件夹中,并按照其readme.md上的说明进行安装。 一种。 git clone b。 cd高清钱包衍生c。 php -r“ readfile(' ');” |...

  • 一时间网上各种介绍区块链的文章层出不穷,但大多数都是从概念层面进行解释的,本文则从技术层面讲解,如何从零开始创建一个区块链应用。本文使用python开发,读者需要了解一些python语言的基础知识。首先创建一个...

  • 【编者按】区块链自诞生那天起就是互联网业界最富有争议与分歧的技术之一。它是比特币和其他加密货币幕后的核心技术,最近几年来引起了广泛的关注。区块链的核心是分布式数据库,任何两方之间可以进行直接交易,而...

  • it派 - {技术青年圈}持续关注互联网、区块链、人工智能领域it派日常小剧场小编认为最快的学习区块链的方式是自己创建一个,本文就用python来创建一个区块链。对数字货币的崛起感到新奇的我们,并且想知道其背后的...

global site tag (gtag.js) - google analytics