Вы здесь

Изучите блокчейн, построив его

Лучший способ понять механизм работы блокчейна - написать свой. Вы здесь потому что тоже помешались на почве роста значения криптовалют. И у вас есть острое желание понять, как работает блокчейн - фундаментальная для криптовалют технология.

Изучите блокчейн, построив его

Но понимание блокчейна штука не легкая - во всяком случае, с моей точки зрения. Мне пришлось вникать в перегруженные видеоролики и неполные руководства, а также терпеть слишком малое число примеров.

Мне нравится обучение на практике. Тогда я начинаю пытаться разобраться в проблеме на уровне кода, что дает хорошее понимание того, как это работает. Если вы похожи на меня, благодаря этому руководству вы получите рабочий блокчейн и знание принципов его работы.

Для кого предназначен этот гайд? Вам необходимо хотя бы на базовом уровне освоить Python и понимать работу HTTP-запросов.

Что нам понадобится из программного обеспечения: Python 3.6, (включая pip), HTTP-клиент (например Postman или Curl) и Flask. Ну и, само собой, без одной чудесной библиотеки никуда - Requests.

pip install Flask==0.12.2 requests==2.18.4

Финальный код доступен тут.

Шаг 1. Построение блокчейна

Для начала нужно создать в наиболее удобном для вас текстовом редакторе файл blockhaine.py.

Представляя блокчейн

Мы создадим 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

Как выглядят блоки?

В каждом блоке, помимо списка транзакций и “доказательства”, хранятся его индекс, отметка времени и хэш предыдущего блока.

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

new_transaction() при сохранении транзакции указывает индекс следующего блока. Именно в него будет помещена транзакция.

Как работает механизм создания блоков

Когда наш 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):
        """
        Create a new Block in the Blockchain
        :param proof: <int> The proof given by the Proof of Work algorithm
        :param previous_hash: (Optional) <str> Hash of previous Block
        :return: <dict> 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: <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
    @property
    def last_block(self):
        return self.chain[-1]
    @staticmethod
    def hash(block):
        """
        Creates a SHA-256 hash of a Block
        :param block: <dict> Block
        :return: <str>
        """
        # 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.

Для примера мы возьмем максимально простую задачу.

Скажем, нужно найти целые числа x и y, хэшированное произведение которых будет заканчиваться на ноль: hash(x * y) = ac23dc...0 . Для нашей “учебной” задачи примем, что x = 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

hash(5 * 21) = 1253e9373e...5e3600155e860

Алгоритм PoW биткоина - Hashcash, по большому счету, сильно похож на пример выше. Майнеры стремятся решить его быстрее конкурентов, чтобы получить вознаграждение за создание блока. В общем, сложность определяется числом идущих подряд в хэше цифр, которые должны равняться нулю.

Сеть при этом способна легко проверить решения.

Внедрение базового доказательства работы

Давайте внедрим сходный алгоритм в наш блокчейн. Наша задача будет звучать так:

“Найдите такое число p, хэш произведения которого и решения из предыдущего блока будет начинаться с 4 нулей”.

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: <int>
        :return: <int>
        """
        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: <int> Previous Proof
        :param proof: <int> Current Proof
        :return: <bool> True if correct, False if not.
        """
        guess = f'{last_proof}{proof}'.encode()
        guess_hash = hashlib.sha256(guess).hexdigest()
        return guess_hash[:4] == "0000"

Регулировать сложность алгоритма мы можем, изменяя число требуемых нулей. Но 4 вполне достаточно. Вы поразитесь насколько увеличивает длительность решения задачи требование найти еще один ноль.

Шаг 2. Блокчейн в качестве API

Нам очень сильно поможет Python Flask Framework. Это микро-фреймворк, благодаря чему с его помощью удобно размечать конечные точки функций “питона”.

Мы зададим следующие методы:

  • /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)

Конечная точка транзакций

Запрос, отправляемый серверу пользователем, выглядит так:

{
"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. Вычислять PoW
  2. Вознаграждать майнера (нас)
  3. Сохранять новосозданные блоки
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

Вот теперь можно начинать работать со своим блокчейном.

Шаг 3. Работа с блокчейном

Работать с API удобнее всего с помощью клиента Postman.

Запуск сервера осуществляется следующей командой:

$ python blockchain.py
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Майнинг запустится по запросу GET на http://localhost:5000/mine

Запрос GET на http://localhost:5000/transactions/new создаст новую транзакцию.

Никто. кстати, не заставляет использовать Postman, с этой задачей прекрасно справится и Curl.

$ curl -X POST -H "Content-Type: application/json" -d '{
"sender": "d4ee26eee15148ee92c6cd394edd974e",
"recipient": "someone-other-address",
"amount": 5
}' "http://localhost:5000/transactions/new"

Давайте посмотрим всю цепочку блоков, используя 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. Консенсус

Смысл блокчейна в децентрализации. А как, черт возьми, мы можем заставить их отображать одну и туже цепочку, если они децентрализованы? Это так называемая проблема Консенсуса и мы не сможем использовать в своей сети более одного узла без алгоритма ее решения.

Создаем реестр узлов

Сперва нужно сообщить своему узлу о “коллегах” в сети.

Для хранения на каждом узле сети реестра других, требуются дополнительные конечные точки:

  1. /nodes/register - создает список URL-адресов других узлов
  2. /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: <str> Address of node. Eg. 'http://192.168.0.5:5000'
        :return: None
        """
        parsed_url = urlparse(address)
        self.nodes.add(parsed_url.netloc)

Set()., который мы использовали - это простой способ добиться того, чтобы ни один узел не сохранялся более 1 раза.

Приводим сеть к консенсусу

Для однозначного решения конфликта примем правило, что единственно верной цепочкой считается наиболее протяженная из валидных.

...
import requests
class Blockchain(object)
    ...
    def valid_chain(self, chain):
        """
        Determine if a given blockchain is valid
        :param chain: <list> A blockchain
        :return: <bool> 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: <bool> 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.

Затем я намайнил несколько блоков на втором узле, чтобы создать более длинную версию цепочки. Затем на узле 1 я обратился к GET /nodes/resolve и при помощи алгоритма консенсуса заменил цепочку на моем узле.

В общем-то, на этом все. Теперь можете собирать друзей и совместно тестировать собственный блокчейн.

Я очень надеюсь, что смог заинтересовать вас в создании чего-нибудь нового и необычного. Я увлечен криптовалютами, так как убежден, что блокчейны очень быстро изменят то, как мы думаем о правительствах, хранении записи и нашей экономике.

PS. Я намерен опубликовать продолжение посвященное валидации транзакций и тому, как можно заработать на своем блокчейне.

Категория: 
Tutorial
Технология: 
3
Ваша оценка: Нет Средняя: 2.5 (1 оценка)
2813 / 0
Аватар пользователя Мирослав Лимм
Публикацию добавил: Мирослав Лимм
Дата публикации: ср, 02/07/2018 - 10:09

Что еще почитать:

Комментарии:

Вроде подробно и с первого прочтения понятно как построить свой блокчейн, думаю стоит попробовать самому. Кто-то уже использовал этот алгоритм? Поделитесь опытом

сб, 08/25/2018 - 12:25

Добавить комментарий