Как создать блокчейн с нуля: пошаговое руководство

Создание блокчейна – это, пожалуй, одна из наиболее перспективных современных задач идейно и технически. Настоящая эра блокчейнов началась относительно недавно, но уже сейчас его технологии активно применяются в самых разных областях, начиная от логистики и заканчивая финансами и государственным управлением. Построить блокчейн могли лишь большие компании – сегодня это достижимо и простым разработчикам.

В этой статье рассмотрим создание блокчейна с нуля – от теоретических и архитектурных основ до написания кода на Python и завершения его запуска на рабочем уровне. По пути разберём все детали процесса, объясним, как происходит каждый этап и поясним причины таких решений.

Что такое блокчейн и как он строится

Блокчейн представляет собой распределенную базу данных, данные которой содержатся в виде цепочки блоков. Каждый блок состоит из множества транзакций или иной информации, времени создания и криптографической связи со своим предыдущим соседом. Это криптографическое значение предыдущего блока позволяет сделать блокчейн неизменяемым: если изменить хоть одну часть блока, хеши всех остальных будут отличаться.

Система работает без использования центрального сервера. Наоборот, у системы есть сеть узлов (nodes) или участников, каждый из которых хранит полную копию блок-цепочки. Для того чтобы новый блок был добавлен в цепочку, его нужно одобрить большинством узлов. Процесс называется консенсусом.

Основные характеристики блокчейна:

• Неизменность. Ставшие частью системы данные не могут быть удалены или изменены.
• Прозрачность. Все участники видят одинаковую версию данных.
• Децентрализация. Нет единственной точки отказа и контроля.

Состав блока: структура и хеширование

Ещё раз отметим важность понимания внутренней структуры блока, перед тем как начинать написание кода. Обычно блок содержит следующие поля:

• index — порядковый номер блока в блок-цепочке.
• timestamp — время создания блока.
• transactions — список транзакций или произвольных данных.
• previous_hash — хеш предыдущего блока.
• nonce — случайное число, используемое при майнинге.
• hash — хеш самого блока, который рассчитывается на основе полей выше.

Каждый хеш рассчитывается с использованием функции хеширования SHA-256. Она преобразует входящие данные любого размера в одну и ту же последовательность небольшой длины. Свойства функции хеширования SHA-256 делают её непригодной для обратного преобразования, что делает её идеальным выбором для системы блокчейн. Первый блок в цепочке называется genesis block (генезис блок). Его предыдущий блок не имеет хеша, поэтому данное поле заполняется нулями.

В коде (Блок 1) реализуем класс Block с рассчитыванием хеширования и класс Blockchain для создания генезис-блока:

import hashlib
import json
from time import time

class Block:
    def __init__(self, index, transactions, previous_hash, nonce=0):
        self.index = index
        self.timestamp = time()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = nonce
        self.hash = self.compute_hash()

    def compute_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True, default=str)
        return hashlib.sha256(block_string.encode()).hexdigest()

class Blockchain:
    def __init__(self):
        self.chain = []
        self.current_transactions = []
        self.nodes = set()
        # Создаём генезис-блок
        self._create_genesis_block()

    def _create_genesis_block(self):
        genesis = Block(0, [], '0' * 64)
        self.chain.append(genesis)

    @property
    def last_block(self):
        return self.chain[-1]

Добавление транзакций и формирование нового блока

Каждая запись данных в системе называется транзакцией. В Bitcoin транзакция представляет собой запись о переводе монет с одного адреса на другой. В корпоративной системе блокчейна транзакцией может стать любое событие — отправка товара или документа или даже изменение статуса контракта.

Транзакции собираются в блок в процессе майнинга. Они добавляются в специальный буфер или «пул» (mempool), где они ждут своего часа. Важно отметить, что транзакция считается подтверждённой только тогда, когда она будет добавлена в блок-цепочку.

В коде (Блок 2) реализуем два метода класса Blockchain:

new_transaction() — для записи транзакции в «пул»;

new_block() — для создания нового блока из накопленных транзакций.

    def new_transaction(self, sender, recipient, amount):
        """Добавляет новую транзакцию в пул."""
        self.current_transactions.append({
            "sender": sender,
            "recipient": recipient,
            "amount": amount,
        })
        return self.last_block.index + 1

    def new_block(self, nonce):
        """Создаёт новый блок из накопленных транзакций."""
        block = Block(
            index=len(self.chain),
            transactions=self.current_transactions,
            previous_hash=self.last_block.hash,
            nonce=nonce,
        )
        self.current_transactions = []  # очищаем пул
        self.chain.append(block)
        return block

Алгоритм консенсуса: Proof of Work и Proof of Stake

Получив транзакцию, участник сети может создать новый блок. Но он должен быть подтверждён другими узлами в системе. При помощи какой технологии это делается? Ответ будет зависеть от выбранного алгоритма консенсуса.

Proof of Work (PoW)

Proof of Work — классический алгоритм, использующийся в Bitcoin. Его принцип достаточно прост: чтобы создать валидный блок, узлу необходимо выбрать такой хеш блока, который будет начинаться с заданного числа нулей. Сложность подбора такого хеша называют сложностью блока.

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

Однако минусом Proof of Work является высокое энергопотребление. По этой причине большинство современных платформ перешло на иные подходы.

Proof of Stake (PoS)

В Proof of Stake право создать новый блок зависит не от вычислительной мощности, а от доли токенов узла в сети. Переход Ethereum на PoS состоялся в 2022 году и позволил снизить энергопотребление сети примерно в 99,95 раза. В корпоративных блокчейнах, таких как Hyperledger Fabric и Quorum, используются и другие подходы, включая Practical Byzantine Fault Tolerance (PBFT) и Raft.

При выполнении нашего примера будет использован классический PoW. Блок 3 содержит реализацию функции proof_of_work():

    DIFFICULTY = 4  # количество ведущих нулей в хеше

    def proof_of_work(self):
        """Подбирает nonce, при котором хеш начинается с нужного числа нулей."""
        nonce = 0
        prefix = '0' * self.DIFFICULTY
        candidate = Block(
            index=len(self.chain),
            transactions=self.current_transactions,
            previous_hash=self.last_block.hash,
            nonce=nonce,
        )
        while not candidate.compute_hash().startswith(prefix):
            nonce += 1
            candidate.nonce = nonce
        return nonce

Разработка API и его интеграция с Flask: использование блокчейна как сервиса

Изолированный блокчейн, работающий на одной машине, это лишь образовательная задача. С точки зрения приложений, чтобы блокчейн был полезен, он должен предоставлять API. Для реализации интерфейса мы будем использовать легкий Python-фреймворк Flask, который за несколько строчек позволит нам сделать из нашего блокчейна веб-сервис.

Нам потребуются три маршрута:

• GET /chain — возвращает всю цепочку блоков в формате JSON.
• POST /transactions/new — добавляет новую транзакцию в пул.
• GET /mine — запускает процесс майнинга блока.

Наши маршруты будут приведены в Блоке 4:

from flask import Flask, jsonify, request
import uuid

app = Flask(__name__)
node_id = str(uuid.uuid4()).replace('-', '')
blockchain = Blockchain()

@app.route('/chain', methods=['GET'])
def full_chain():
    response = {
        "chain": [b.__dict__ for b in blockchain.chain],
        "length": len(blockchain.chain),
    }
    return jsonify(response), 200

@app.route('/transactions/new', methods=['POST'])
def new_transaction():
    data = request.get_json()
    required = ["sender", "recipient", "amount"]
    if not all(k in data for k in required):
        return 'Missing fields', 400
    idx = blockchain.new_transaction(data["sender"], data["recipient"], data["amount"])
    return jsonify({"message": f"Transaction added to block {idx}"}), 201

@app.route('/mine', methods=['GET'])
def mine():
    blockchain.new_transaction(sender="0", recipient=node_id, amount=1)
    nonce = blockchain.proof_of_work()
    block = blockchain.new_block(nonce)
    response = {"message": "New block mined", "index": block.index,
                "hash": block.hash, "transactions": block.transactions}
    return jsonify(response), 200

if __name__ == '__main__':
    import sys
    port = int(sys.argv[1]) if len(sys.argv) > 1 else 5000
    app.run(host='0.0.0.0', port=port)

Синхронизация узлов и алгоритм консенсуса в сети

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

У каждого узла есть список других узлов сети. При добавлении нового блока, этот факт известен только текущему узлу, и ему необходимо рассказать об этом другим узлам сети.

Для этого применяется «правило самой длинной цепи» (longest chain rule): если узел узнаёт, что у своего соседа цепочка длиннее и валидна, он заменяет собственную.

Алгоритм регистрации соседних узлов и алгоритм консенсуса показаны в Блоке 5:

import requests as req
from urllib.parse import urlparse

    def register_node(self, address):
        parsed = urlparse(address)
        self.nodes.add(parsed.netloc or parsed.path)

    def valid_chain(self, chain_data):
        prefix = '0' * self.DIFFICULTY
        for i in range(1, len(chain_data)):
            blk = chain_data[i]
            prev = chain_data[i - 1]
            if blk['previous_hash'] != prev['hash']:
                return False
            if not blk['hash'].startswith(prefix):
                return False
        return True

    def resolve_conflicts(self):
        """Заменяет цепочку, если у соседа длиннее и валиднее."""
        new_chain = None
        max_len = len(self.chain)
        for node in self.nodes:
            try:
                r = req.get(f'http://{node}/chain', timeout=5)
                data = r.json()
                if data['length'] > max_len and self.valid_chain(data['chain']):
                    max_len = data['length']
                    new_chain = data['chain']
            except Exception:
                continue
        if new_chain:
            self.chain = self._dict_list_to_blocks(new_chain)
            return True
        return False

Отметим важное: в действительности production-блокчейны реализуют гораздо более сложные P2P-протоколы для обнаружения и синхронизации узлов. В Bitcoin и Ethereum узлы обмениваются информацией специализированными gossip-протоколами. Наш пример — упрощённая, но концептуально корректная демонстрация принципа.

Как создать блокчейн-платформу: от прототипа до продакшна

В принципе написать рабочий блокчейн на Python за несколько часов можно. Однако создание полноценной blockchain-платформы — это отдельный проект со своим жизненным циклом и спецификой реализации.

Этап 1. Проектирование архитектуры

На данном этапе принимаются ключевые решения: потребуется ли блокчейн публичный или частный, какой консенсус-алгоритм выбрать, какие данные хранить в цепочке, необходимы ли смарт-контракты. Часто правильный подход к проекту будет заключаться в том, чтобы не создавать новый блокчейн, а развивать уже существующие платформы (Hyperledger Fabric, Ethereum, Substrate).

Этап 2. Выбор технологической основы

В корпоративных проектах часто используется Go, Rust или Java — именно эти языки обеспечивают лучшую производительность по сравнению с Python. Python хорошо подходит для прототипов и обучения. Смарт-контракты для Этерии пишутся на Solidity; в Hyperledger Fabric их делают на Go или JavaScript chaincode.

Этап 3. Разработка смарт-контрактов

Смарт-контракты — это программы, выполняемые в блокчейне при возникновении определенных условий. Они автоматизируют процесс проведения сделок, снижают степень зависимости от посредников и обеспечивают исполнимость сделок без дополнительного участника. Разработка и проверка смарт-контракта представляет собой отдельное инженерное направление, которое требует специфического опыта: неправильно настроенная программа может привести к потере средств навсегда.

Этап 4. Создание блокчейн-узла и тестирование

На этапе создания блокчейн-узла требуется настроить его сеть, консенсус, систему хранения данных и API. Тестирование blockchain сложнее традиционного ПО: кроме прочего, нужно проверять работу узла при разрывах связи, атаках на 51% и условиях гонок при одновременном майнинге. Для этого используются специализированные сети для тестирования — testnets.

Этап 5. Запуск и масштабирование

Вывод блокчейн-сети в продакшен требует начальной подготовки сети хотя бы нескольких надёжных узлов, которые составят консорциум. После этого важно отслеживать пропускную способность (ТPS — транзакций в секунду), задержки и состояния консенсуса. Важным шагом блокчейна станет масштабирование, для которого используют шардирование, Layer 2 решения и оптимизацию консенсуса.

Когда стоит создать свой блокчейн, а когда использовать существующий

Одним из наиболее частых вопросов при рассмотрении блокчейн-проектов является вопрос — действительно ли нужно создать блокчейн с нуля?

Это зависит от нужд по контролю, доверию и децентрализации проекта.

Самостоятельная разработка блокчейна обоснована в случае:

• Надобности уникального механизма консенсуса, которого нет среди существующих платформ.
• Необходимости сверхпроизводительности с кастомной оптимизацией под конкретную задачу.
• Полного контроля над протоколом и параметрами сети.
• Создания новой публичной блокчейн-экосистемы с новыми токеномикой.

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

• Hyperledger Fabric – для корпоративных частных сетей с правовым разделением доступа.
• Ethereum / Polygon – для публичных приложений со смарт-контрактами.
• Substrate (Polkadot) – для кастомизации блокчейнов без разработки протокола с нуля.
• R3 Corda – для финансовых проектов со специфическими задачами.

Использование готовой платформы позволит сэкономить месяцы разработки и повысит безопасность – поскольку ядра этих платформ были многократно аудированы и battle-tested в промышленном использовании.

Сколько стоит разработать блокчейн платформу?

Основным критериями стоимости являются следующие моменты:

• Тип блокчейна — публичный, частный или консорциумный. Частные сети дешевле в запуске, но требуют собственной инфраструктуры.
• Степень кастомизации – готовая платформа с кастомизацией или разработка протокола с нуля.
• Использование смарт-контрактов и их уровень сложности.
• Наличие интеграций с другими системами – ERP, CRM, государственный реестр и т.д.
• Объем работы по тестированию, безопасности и документации.

Ориентировочные диапазоны:

• MVP блокчейна на основе готовой платформы – от 300 000 до 1 000 000 рублей, от 1 до 3 месяцев разработки.
• Корпоративное решение с кастомизацией и интеграциями – от 1 до 5 млн рублей и более, от 3 до 9 месяцев разработки.
• Разработка собственного протокола с нуля – от 5 млн рублей, от 6 до 18 месяцев разработки в зависимости от сложности.

Это предварительные оценки. Точная стоимость разработки рассчитывается на основе анализа и технического задания.

Как запустить API блокчейн: проверка работоспособности системы

После написания кода и настройки Flask-сервера выполняется запуск узла командой python blockchain.py. Стандартно сервер начинает работу на порте 5000. Проверить это можно с помощью curl или Postman.

Во-первых, мы записываем транзакцию путем отправки POST-запроса к /transactions/new, телом которого является строка {«sender»: «alice», «recipient»: «bob», «amount»: 10}. Далее делаем GET-запрос к адресу /mine и запускаем майнинг, который завершится формированием нового блока на сервере. И наконец, GET /chain покажет цепочку блоков.

Для проверки синхронизации запустите второй узел на другом порте, регистрируем его на сайте первой машины при помощи POST /nodes/register и вызываем GET /nodes/resolve – второй узел синхронизирует цепочку с первым.

Итог: что вы сделали и что дальше?

Таким образом, мы прошли путь от концепции до работающего прототипа: реализовали структуру блока с хешированием данных через алгоритм SHA-256, добавили транзакции и логику создания блоков, реализовали концепцию Proof of Work, обернули все это в API на Flask и добавили узловую синхронизацию на основе принципа «самой длинной цепочки».

Это минималистичный, но концептуально полный блокчейн. Здесь нет кошельков, подписи транзакций, системы обнаружения узлов по P2P-протоколам и сетевой обвязки — но здесь есть все ключевые элементы, которые делают это решение блокчейном.

Следующие шаги для тех, кому хочется двигаться дальше: изучение концепций цифровых подписей (ECDSA), реализация верификации транзакций с использованием публичного ключа, разработка P2P-сети с использованием WebSocket или libp2p, а также знакомство со Solidity и смарт-контрактами на Ethereum.

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

Часто задаваемые вопросы

Как создать блокчейн?

Блокчейн создаётся в виде цепочки блоков, в каждом из которых содержится информация о данных, времени их создания и хеш предыдущего блока. Сами разработки могут включать реализацию структуры блока, выбор алгоритма консенсуса (Proof of Work/Proof of Stake и так далее) и сетевого уровня.

Можно ли сделать блокчейн на Python?

Да, можно. Прототипированию блокчейна отлично подходит Python благодаря встроенной библиотеке хеширования (SHA-256 из библиотеки hashlib) и простоте создания API с помощью Flask. При этом такой прототип вполне будет работать для обучения и демонстрации концепции, хотя для использования на продакшене предпочтительнее другие языки (Go, Rust или Java).

Можно ли сделать собственную криптовалюту?

Технически это возможно. Новая криптовалюта — это блокчейн с добавлением уровня токеномики: адресов кошельков, подписей транзакций и механизмов эмиссии. Для этого можно форкнуть Bitcoin, сделать токен ERC20 на основе Ethereum или создать собственный блокчейн и протокол. Но юридическая сторона вопроса сильно зависит от страны — в России выпуск цифровых финансовых активов регулируется федеральным законом №259-ФЗ.

Как сделать кошелек для блокчейна?

Кошелек — это пара криптографических ключей: публичный ключ (адрес кошелька) и приватный ключ (для подписи транзакций). Получается в результате работы алгоритмов ECDSA или Ed25519. Полученный открытый ключ перекодируется с использованием процедур шифрования в адрес кошелька. Кошелёк не содержит внутри себя каких-либо денежных средств. Он содержит пару ключей доступа к записям в блокчейн.

Как создать блокчейн-платформу для бизнеса?

Создание такой платформы состоит из следующих этапов: определение типологии сети, выбор подходящего блокчейн-решения (Hyperledger Fabric, Ethereum, Substrate), разработка смарт-контрактов, интеграция со старой системой, и настройки. Определённый набор работ занимает от одного месяца до девяти в зависимости от сложности и времени разработки проекта.

Каковы основные различия между публичным и частным блокчейном?

В публичном блокчейне (Bitcoin, Ethereum) участником может стать любой желающий, иметь возможность отправлять транзакции, размещать узел, получать информацию с него. В случае с частным блокчейном (внутренним) доступ к нему ограничен и только после прохождения процедуры идентификации и достижения консенсуса среди доверенных узлов. Частные сети функционируют быстрее и не используют токены.

Что это за понятие «смарт-контракт» и нужно ли его использовать?

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

Как выбрать алгоритм консенсуса для своего блокчейна?

Выбор зависит от требований. Proof of Work надёжен и хорошо изучен, но энергоёмок — подходит для публичных сетей с высокими требованиями к безопасности. Proof of Stake эффективнее по ресурсам, используется в Ethereum и многих альткоинах. PBFT и Raft применяются в корпоративных блокчейнах: они быстрые и финальные, но требуют доверенных участников.