Самый быстрый способ изучить работу Блокчейнов – это создать свой блокчейн. Стоит лишь только попробовать!
Скорее всего вы здесь, также, как и я, потому что были недовольны резким подъемом Криптовалюты. И вы хотите узнать, как же работают Блокчейны – фундаментальная технология, которая стоит за всеми криптовалютами.
Но понять, как работают Блокчейны не так просто – ну или, как минимум для меня, это сложно. Я с трудом пробирался сквозь множество непонятных видеороликов, сомнительных туториалов и боролся с сильным разочарованием от очень малого количества примеров. Поэтому мы с вами напишем свой блокчейн.
Вообще, я люблю изучать что-либо практическим путём. Это заставляет меня разобраться с сутью вопроса на уровне кода, который позволяет уловить суть происходящего. Если вы делаете точно также, то к концу этого туториала, у вас будет полностью функционирующий свой Блокчейн, и твёрдое понимание того, как они работают.
Перед тем как мы начнем…
Обратите внимание, что блокчейн – это неизменяемая последовательная цепочка записей, называемых Блоками. Они могут состоять из транзакций, файлов, или любой другой информации, которая вам необходима. Но самым важным здесь является то, что все они связаны вместе с помощью хэшей.
Если вы не уверены в том, что такое хэш, то вот объяснение.
На кого нацелен данный туториал?
У вас не должно возникать трудностей с чтением синтаксиса и написанием базовых вещей на Python. Кроме того, у вас должно быть понимание того, как работают HTTP-запросы, поскольку обращаться к нашему Блокчейну мы будем именно через них.
Что вам необходимо?
Убедитесь в том, что у вас установлен Python 3.6+ (также как и pip). Вам также необходимо установить библиотеку Flask и прекрасную библиотеку Request:
pip install Flask==0.12.2 requests==2.18.4
О, вам также понадобится HTTP-клиент, наподобие Postman или cURL. Но все будет дальше.
Где можно найти окончательную версию?
Исходный код будет доступен здесь.
…
Шаг 1: Создаем свой блокчейн
Запустите ваш любимый редактор кода или IDE, лично мне нравится PyCharm. Создайте новый файл с названием blockchain.py. Мы будем использовать только один файл, но если вы вдруг запутаетесь, то всегда можете обратиться к исходному коду.
Представление Блокчейна
Создадим класс Blockchain, конструктор которого будет создавать изначально пустой список (для хранения нашего блокчейна), и еще один для хранения транзакций. Ниже приведен макет нашего класса:
class Blockchain(object): def __init__(self): self.chain = [] self.current_transactions = [] def new_block(self): # Создает новый Блок и добавляет его к цепочке pass def new_transaction(self): # Добавляет новую транзакцию к списку транзакций pass @staticmethod def hash(block): # Хэшируем блоки pass @property def last_block(self): # Возвращает последний блок в цепочке pass
Наш класс blockchain отвечает за управление цепочкой. В нем будут хранится транзакции и некоторые вспомогательные методы для добавления блоков в цепочку. Давайте же начнем использовать некоторые из методов.
Что из себя представляет Блок?
Каждый блок содержит в себе индекс, временную метку (timestamp, по Unix времени), список транзакций, доказательность (proof, подробнее об этом позже) и хэш предыдущего Блока.
Далее приведен пример того, как выглядит отдельный Блок:
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):
"""
Создает новую транзакцию для того чтобы перейти к следующему искомому Блоку
:параметр sender: <str> Адрес отправителя
:параметр recipient: <str> Адрес получателя
:параметр amount: <int> Количество
:return: <int> Индекс Блока, в котором будет хранится данная транзакция
"""
self.current_transactions.append({
'sender': sender,
'recipient': recipient,
'amount': amount,
})
return self.last_block['index'] + 1
После того, как наш метод добавил транзакцию в список, то он возвращает индекс блока, в который будет добавлена транзакция – следующий искомый блок. Позже, для пользователя, отправляющего транзакцию, это будет полезно.
Создание новых блоков, чтобы реализовать свой блокчейн
После того, как мы создали экземпляр нашего Блокчейна, нам необходимо заполнить его исходным блоком – блок у которого нет предшественников. Также нам необходимо добавить «proof» в наш исходный блок, который является результатом анализа (или алгоритма «доказательство выполнения работы»). По поводу анализа мы поговорим позднее.
Кроме этого, для создания исходного блока в нашем конструкторе, нам также необходимо добавить следующие методы: 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):
"""
Создаем новый блок в нашем Блокчейне
:параметр proof: <int> proof полученный после использования алгоритма «Доказательство выполнения работы»
:параметр previous_hash: (Опциональный) <str> Хэш предыдущего Блока
: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]),
}
# Сбрасываем текущий список транзакций
self.current_transactions = []
self.chain.append(block)
return block
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> Индекс блока который будет хранить в себе эту транзакцию
"""
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):
"""
Создает a SHA-256 хэш блока
:параметр block: <dict> Блок
:return: <str>
"""
# Мы должны быть уверены что наш Словарь упорядочен, или мы можем непоследовательные хэши
block_string = json.dumps(block, sort_keys=True).encode()
return hashlib.sha256(block_string).hexdigest()
Код выше должен быть всем ясен и понятен – я добавил некоторое количество комментариев и немного строк документации, чтобы все было максимально прозрачно. Мы практически закончили с представлением нашего блокчейна. Однако на данном этапе, вы должны быть удивлены тому как новые блоки создаются, формируются и майнятся.
Разбираемся с алгоритмом «Доказательство выполнения работы»
Алгоритм «Доказательство выполнения работы» (PoW) – это то, как новые блоки создаются или майнятся в блокчейне. Целью алгоритма PoW является нахождение такого числа (метки), которое будет решать проблему. Число должно быть таким, чтобы его было сложно найти и легко проверить. Говоря в вычислительном отношении не важно кем в сети это может быть сделано. В этом и заключается основная идея данного алгоритма.
Итак, давайте взглянем на простой пример, которой поможет нам во всем разобраться.
Предположим, что хэш некоторого целочисленного числа x, умноженного на другое целочисленное число y, должен заканчиваться на 0. Следовательно, hash(x * y) = ac23dc...0. И для нашего упрощенного примера исправим x на 5. Реализуем это в 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. Поскольку полученный хэш заканчивается на 0:
hash(5 * 21) = 1253e9373e...5e3600155e860
В сфере Биткоинов, алгоритм «Доказательство выполнения работы» называется Hashcash. И он не сильно отличается от нашего базового примера выше. Это алгоритм, который майнеры используют в гонке по решению задачи создания новых блоков. Как правило, сложность определяется количеством символов, которые необходимо обнаружить в строке. После чего майнеры получают награду за свое решение в качестве биткойна при транзакции.
Сеть может легко проверить их решение.
Реализация простого алгоритма PoW
Давайте реализуем простой алгоритм для того, чтобы реализовать свой блокчейн. Наше правило будет аналогично приведенному выше примеру:
Ищем число p, которое при хэшировании с решением предыдущего блока будет создавать хэш с четырьмя лидирующими нулями.
import hashlib
import json
from time import time
from uuid import uuid4
class Blockchain(object):
...
def proof_of_work(self, last_proof):
"""
Простой алгоритм Proof of Work:
- Ищем число p' такое, чтобы hash(pp') содержал в себе 4 лидирующих нуля, где p это предыдущий p'
- p это предыдущий proof, а p' это новый proof
:параметр 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):
"""
Проверяем Proof: Содержит ли hash(last_proof, proof) 4 лидирующих нуля?
:параметр last_proof: <int> предыдущий Proof
:параметр proof: <int> Тукущий Proof
:return: <bool> True если все верно, иначе False.
"""
guess = f'{last_proof}{proof}'.encode()
guess_hash = hashlib.sha256(guess).hexdigest()
return guess_hash[:4] == "0000"
Для регулирования сложности алгоритма, мы можем модифицировать количество лидирующих нулей. Одна четырех будет достаточно. Вы можете попробовать сами и понять, что добавление одного единственного лидирующего нуля приведет к гигантской разнице во времени поиска решения.
Наш класс практически готов, и мы готовы начать взаимодействовать с ним посредствам HTTP-запросов.
…
Шаг 2: Свой блокчейн в качестве API
Мы будем использовать фреймворк Flask. Данный микро-фреймворк упрощает размещение конечных точек (endpoints) в Python-функциях. Это позволит нам обращаться к нашему блокчейну за счет веб-соединения с помощью HTTP-запросов.
Создадим три метода:
- /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):
...
# Создаем экземпляр нашего узла
app = Flask(__name__)
# Генерируем уникальный глобальный адрес для этого узла
node_identifier = str(uuid4()).replace('-', '')
# Создаем экземпляр 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: Создаем экземпляр узла. Более подробно узнать о Flask можно здесь.
- Строка 18: Генерируем случайное имя для нашего узла;
- Строка 21: Создаем экземпляр класса Blockchain;
- Строки 24-26: Создаем endpoint для метода /mine, который является GET-запросом;
- Строки 28-30: Создаем endpoint для метода /transactions/new, который является POST-запросом, поскольку мы будем отправлять сюда данные;
- Строки 32-38: Создаем endpoint для метода /chain, который будет возвращать весь Блокчейн;
- Строки 40-41: Запускаем наш сервер на порт 5000.
Endpoint для транзакций
Вот так будет выглядеть запрос транзакции. То есть, именно эту информацию пользователь отправляет на сервер:
{
"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()
# Проверяем, что обязательные поля переданы в POST-запрос
required = ['sender', 'recipient', 'amount']
if not all(k in values for k in required):
return 'Missing values', 400
# Создаем новую транзакцию
index = blockchain.new_transaction(values['sender'], values['recipient'], values['amount'])
response = {'message': f'Transaction will be added to Block {index}'}
return jsonify(response), 201
Endpoint для майнинга
Наш endpoint майнинга – это то, где происходит магия, и в ней нет ничего сложного. Здесь совершаются три следующих вещи:
- Расчет алгоритма PoW;
- Майнер(ы) получают награду в виде транзакции, которая гарантируем им 1 биткойн;
- Формирование нового блока, путем его добавления в цепочку.
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():
# Мы запускаем алгоритм PoW для того чтобы найти следующий proof...
last_block = blockchain.last_block
last_proof = last_block['proof']
proof = blockchain.proof_of_work(last_proof)
# Мы должны получить награду за найденный proof.
# Если sender = "0", то это означает что данный узел заработал биткойн.
blockchain.new_transaction(
sender="0",
recipient=node_identifier,
amount=1,
)
# Формируем новый блок, путем добавления его в цепочку
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. На данном этапе мы закончили с подготовкой нашего блокчейна и теперь готовы взаимодействовать с ним.
Шаг 3: Взаимодействие с нашим Блокчейном
Вы можете использовать простой, но уже устаревший cURL или Postman, для взаимодействия с нашим API через сеть.
Запускаем наш сервер:
$ python blockchain.py* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
Давайте попробуем смайнить блок. Для этого воспользуемся GET-запросом на http://localhost:5000/mine:
Создадим новую транзакцию с помощью POST-запроса на 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: Консенсус
Пока, все что мы делали, это круто. Мы получили базовый Блокчейн, который может принимать транзакции, тем самым позволяя нам майнить новые Блоки. Однако вся суть Блокчейнов заключается в том, что они должны быть децентрализованы. Но если блокчейны децентрализованы, то как мы можем гарантировать, что все они отражают одну и ту же цепочку? Данная проблема называется проблемой Консенсуса (конфликтов). Мы реализуем алгоритм Консенсуса, если мы конечно хотим, чтобы в нашей сети было больше одного узла.
Регистрация новых узлов
Перед тем как мы сможем реализовать алгоритм Консенсуса, нам необходимо придумать способ, как наши узлы будут знать о своих «соседях» в сети. Каждый узел в нашей сети будет хранить в себе запись о других узлах в сети. Итак, нам необходимо еще некоторое количество endpoint-ов:
- /nodes/register чтобы можно было принимать список новых узлов в форме URL;
- /nodes/resolve для реализации нашего алгоритма Консенсуса, который разрешит любые конфликтные ситуации, чтобы каждый узел содержал корректную цепочку.
Для всего этого нам необходимо модифицировать конструктор нашего Блокчейна, и предоставить метод по регистрации узлов:
... from urllib.parse import urlparse ... class Blockchain(object): def __init__(self): ... self.nodes = set() ... def register_node(self, address): """ Добавляем новый узел в список узлов :параметр address: <str> Адрес узла, например: '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):
"""
Определяем, что данный блокчейн прошел проверку
:параметр chain: <list> Блокчейн
:return: <bool> True если прошел проверку, иначе False
"""
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")
# Проверяем, что хэш этого блока корректен
if block['previous_hash'] != self.hash(last_block):
return False
# Проверяем, что алгоритм PoW корректен
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: <bool> True если наша цепочка была заменена, False если это не так
"""
neighbours = self.nodes
new_chain = None
# Мы ищем цепочки длиннее наших
max_length = len(self.chain)
# Берем все цепочки со всех узлов нашей сети и проверяем их
for node in neighbours:
response = requests.get(f'http://{node}/chain')
if response.status_code == 200:
length = response.json()['length']
chain = response.json()['chain']
# Проверяем, что цепочка имеет
# максимальную длину и она корректна
if length > max_length and self.valid_chain(chain):
max_length = length
new_chain = chain
# Заменяем нашу цепочку, если нашли другую,
# которая имеет большую длину и является корректной
if new_chain:
self.chain = new_chain
return True
return False
Первый метод valid_chain () отвечает за проверку цепочки на корректность, путем прогонки её по циклу через каждый блок, в котором сравнивается хэш и proof.
resolve_conflicts() – это метод который в цикле проходит по всем соседним узлам, скачивает их цепочки и проверяет их, используя метод выше. Если найдена необходимая цепочка, то мы заменяем текущую на эту.
Давайте зарегистрируем два endpoint-а в нашем 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.
После чего я замайнил новые блоки на узел 2, для того чтобы цепочка стала длиннее. Потом, я вызвал GET /nodes/resolve на узел 1, где цепочка была заменена по алгоритму Консенсуса:
И это просто обёртка… Объединитесь с друзьями для того, чтобы затестить свой Блокчейн.
…
Итак, мы с вами написали свой блокчейн. Я надеюсь, что данная статья способствует тому, что вы создадите что-то новое для себя.
Дополнение: Также планирую продолжить со второй частью статьи, где мы будем расширять свой блокчейн, для того чтобы у нас был свой механизм проверки транзакций. Кроме того, обсудим некоторые способы, с помощью которых вы сможете запустить свой Блокчейн в работу.
Другие материалы по теме
Простейший блокчейн своими руками
10 полезных ресурсов по технологии blockchain
Ссылка на оригинальную статью
Перевод: Александр Давыдов
Комментарии