О нас
ФФ - Главный криптодайджест! Все самые интересные и важные события сразу на русском.
Платформа Trader trends (tt.ff.ru) – сервис решений для трейдеров и держателей криптоактивов. Подключайся и следи за портфелями профессиональных трейдеров.
Самый быстрый способ узнать, как работают блокчейны - это построить один.
Вы здесь, потому что вы взволнованы ростом криптовалют. И вы хотите знать, как работают блокчейны - фундаментальная технология, стоящая за ними. Но понять блокчейн нелегко.
После изучения огромного количества материала было составлено это руководство, которое поможет вам создать функционирующий блокчейн и твердо понимать, как он работает.
Прежде чем начать…
Помните, что блокчейн - это неизменяемая последовательная цепочка записей, называемых блоками. Они могут содержать транзакции, файлы или любые данные, которые вам нравятся. Но важно то, что они связаны друг с другом с помощью хэшей.
Для кого создано это руководство? Тем, кто имеет базовые навыки в чтении и написании базового Python, а также некоторое представление о том, как работают HTTP-запросы, так как мы будем взаимодействовать с нашим блокчейном по HTTP.
Что для этого необходимо? Убедитесь, что Python 3.6+ (вместе с pip) установлен на ваш компьютер. Вам также нужно будет установить Flask и Requests library.
Вам также понадобится HTTP-клиент, например, Postman или cURL. Подойдет любой.
Шаг 1: построение блокчейна
Откройте свой любимый текстовый редактор или IDE. Создайте новый файл с именем blockchain.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
Созданный класс отвечает за управление цепочкой. Он будет хранить транзакции и некоторые вспомогательные методы для добавления новых блоков в цепочку. Давайте начнем конкретизировать некоторые методы.
Как выглядит блок?
Каждый блок имеет индекс, временную метку (по Unix), список транзакций, доказательство и хэш предыдущего блока.
Вот так, например, может выглядеть один блок:
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: 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
После того, как new_transaction() добавит транзакцию в список, она добавит индекс блока, в который будет добавлена транзакция следующего блока, который будет добыт. Это пригодится позже пользователю, отправляющему транзакцию.
Создание новых блоков
Когда блокчейн будет создан, нам нужно будет заполнить его генезисным блоком - блоком без предшественников. Также нужно добавить «доказательство» в этот блок, который является результатом майнинга (или доказательством проделанной работы). О майнинге мы поговорим позже.
Кроме создания генезисного блока нужно будет также конкретизировать методы для 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: 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):
"""
Creates a new transaction to go into the next mined Block
: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):
"""
Creates a SHA-256 hash of a Block
: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) - это то, как создаются или майнятся новые блоки на блокчейне. Цель PoW - найти число, которое решит эту проблему. Число трудно найти, но легко проверить с помощью вычислений любым участником сети. Это основная идея доказательства работы.
Предлагаем рассмотреть очень простой пример, чтобы понять принцип работы алгоритма.
Предположим, что хэш некоторого целого числа x, умноженного на другое число y, должно заканчиваться на 0. Итак, хэш(x * y) = ac23dc...0. Допустим x = 5. В Python это будет выглядеть так:
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, так как произведенный хэш заканчивается на 0:
hash(5 * 21) = 1253e9373e...5e3600155e860
Алгоритм доказательства работы биткоина называется Hashcash. Он примерно похож на пример, приведенный выше. Это алгоритм, который майнеры решают в гонке, чтобы создать новый блок. Сложность определяется количеством символов, которые нужно найти в строке. Затем майнеры получают вознаграждение за решение алгоритма в виде монеты в транзакции. Сеть может легко проверить их решение.
Реализация базового алгоритма доказательства работы
Реализуем аналогичный алгоритм для нашего блокчейна. Правило такое же, что и для примера выше:
Найти число p, которое при хэшировании с решением предыдущего блока образует хэш с 0000.
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:
:return:
"""
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: 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"
Добавление хотя бы одного нуля спереди числа имеет огромное значение для времени, необходимого для поиска решения.
Шаг 2: наш Блокчейн как API
Мы будем использовать фреймворк Python Flask. Это микрофреймворк, который позволяет легко сопоставлять конечные точки с функциями 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):
...
# 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: создать экземпляр класса для блокчейна.
Строка 24-26: создать /mine endpoint, которая является запросом GET.
Строка 28-30: создать /transactions/, которая является 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
Конечная точка майнинга
Конечная точка майнинга - это место, где происходит магия. Нужно сделать только три вещи:
- Рассчитать доказательство работы
- Вознаградить майнера (то есть нас) монетой, добавив транзакцию
- Создать новый блок, добавив его в цепочку
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'],
}
Обратите внимание, что получателем добытого блока является адрес нашего узла.
Шаг 3: взаимодействие с нашим блокчейном
Запуск сервера:
Вы можете использовать обычный старый cURL или Postman для взаимодействия с нашим API по сети.
Давайте попробуем начать майнинг блока, используя запрос 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: Консенсус
Теперь у нас есть базовый блокчейн, который принимает транзакции и позволяет нам майнить новые блоки. Но весь смысл блокчейна в том, что они должны быть децентрализованы. И если они децентрализованы, как мы можем гарантировать, что все они отражают одну и ту же цепочку? Это называется проблемой консенсуса, и нам придется реализовать алгоритм консенсуса, если мы хотим иметь более одного узла в нашей сети.
Регистрация новых узлов
Прежде чем мы сможем реализовать алгоритм консенсуса, нам нужно сообщить узлу о соседних узлах в сети. Каждый узел в сети должен вести реестр других узлов в сети. Таким образом, нам понадобится еще несколько конечных точек:
/nodes/register принимает список новых узлов в виде URL-адресов.
/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: 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):
"""
This is our Consensus Algorithm, it resolves conflicts
by replacing our chain with the longest one in the network.
:return: 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.
Затем я получил при помощи майнинга несколько новых блоков на узле 2, чтобы убедиться, что цепочка была длиннее. После этого я вызвал GET/nodes/resolve на узле 1, где цепочка была заменена алгоритмом консенсуса:
И на этом все. Попробуйте протестировать блокчейн вместе с друзьями.
Читайте также: Малайзия планирует принять криптозакон в 1 квартале 2019 года