Что такое блокчейн простыми словами

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

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

Основные понятия: блок, хеш, цепочка

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

Хеш представляет собой уникальную цифровую подпись блока, создаваемую с помощью криптографических алгоритмов (чаще всего SHA-256). Этот идентификатор генерируется на основе всех данных, содержащихся в блоке, и даже малейшее изменение информации приведет к кардинально другому хешу. Кроме собственного хеша, каждый блок содержит хеш предыдущего блока, что и создает неразрывную цепочку — blockchain.

Скриншот домашней страницы web3.py
Показывает официальный ресурс библиотеки, где собраны документация и примеры. Полезно для новичков, чтобы быстро найти нужные материалы.

Почему блокчейн называют неизменяемым реестром

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

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

Где применяют: криптовалюта, NFT, контракты, безопасность

Первоначально блокчейн был создан как основа для Bitcoin, но сегодня эта технология нашла применение в самых разных сферах:

• Криптовалюты используют блокчейн для ведения реестра всех транзакций, обеспечивая прозрачность и защиту от двойного расходования средств.
• NFT (невзаимозаменяемые токены) позволяют подтверждать право собственности на цифровые активы — от произведений искусства до игровых предметов.
• Смарт-контракты автоматизируют выполнение соглашений без участия посредников, исполняясь при соблюдении заранее определенных условий.
• Системы безопасности применяют блокчейн для защиты от подделок документов, отслеживания цепочек поставок и обеспечения целостности критически важных данных.

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

Почему Python — популярный язык для блокчейн-разработки

Хотя первоначальная реализация Bitcoin была написана на C++, современные разработчики все чаще обращаются к Python для создания блокчейн-проектов. Этот выбор обусловлен целым рядом технических и практических преимуществ, которые делают Python идеальным инструментом для прототипирования и разработки распределенных систем.

Преимущества Python: простота, скорость прототипирования

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

В отличие от компилируемых языков, Python позволяет разработчикам мгновенно тестировать изменения без длительного процесса компиляции. Это критически важно при разработке блокчейн-протоколов, где необходимо экспериментировать с различными алгоритмами консенсуса, механизмами валидации и криптографическими схемами.

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

Поддержка сторонних библиотек и фреймворков

Экосистема Python предлагает богатый набор специализированных инструментов для блокчейн-разработки. Модуль hashlib предоставляет готовые реализации криптографических хеш-функций, включая SHA-256, который является стандартом в большинстве блокчейн-сетей.

Для создания распределенных приложений доступны фреймворки вроде Flask и FastAPI, позволяющие быстро развернуть API для взаимодействия с блокчейном. Библиотека requests упрощает реализацию сетевого взаимодействия между узлами, а bitcoinlib и web3.py предоставляют готовые решения для работы с существующими блокчейн-сетями.

Сравнение синтаксиса с JavaScript

Рассмотрим, как различается реализация базовых блокчейн-операций в Python и JavaScript:

Создание класса блока:

# Python

class Block:

    def __init__(self, index, data, previous_hash):

        self.index = index

        self.data = data

        self.previous_hash = previous_hash

        self.hash = self.compute_hash()

// JavaScript

class Block {

    constructor(index, data, previousHash) {

        this.index = index;

        this.data = data;

        this.previousHash = previousHash;

        this.hash = this.computeHash();

    }

}

Вычисление хеша:

# Python

def compute_hash(self):

    block_string = json.dumps(self.__dict__, sort_keys=True)

    return hashlib.sha256(block_string.encode()).hexdigest()

// JavaScript

computeHash() {

    return crypto.createHash('sha256')

        .update(JSON.stringify(this))

        .digest('hex');

}

Как видим, Python-код отличается большей лаконичностью и читаемостью, что особенно важно при работе в команде или при последующем аудите безопасности блокчейн-проекта. Но теория без практики — это лишь половина пути. Давайте перейдем к созданию реального блокчейна на Python.

Как создать простой блокчейн на Python с нуля

Теория становится по-настоящему понятной только через практику. Мы создадим функциональный блокчейн, который продемонстрирует все ключевые принципы этой технологии: от криптографического хеширования до алгоритма доказательства выполнения работы (Proof of Work).

Установка окружения: Python, hashlib, time

Для нашего проекта потребуются только встроенные модули Python, что подчеркивает элегантность языка. Нам понадобятся:

• hashlib — для криптографических операций.
• json — для сериализации данных блоков.
• time — для работы с временными метками.

Начнем с импорта необходимых библиотек:

import hashlib

import json

from time import time

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

Класс Block: структура, поля, метод compute_hash

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

class Block:

    def __init__(self, index, data, timestamp, previous_hash):

        self.index = index

        self.data = data

        self.timestamp = timestamp

        self.previous_hash = previous_hash

        self.nonce = 0  # Для алгоритма Proof of Work

        self.hash = self.compute_hash()

   

    def compute_hash(self):

        """

        Вычисляет SHA-256 хеш блока на основе всех его данных

        """

        block_string = json.dumps({

            'index': self.index,

            'data': self.data,

            'timestamp': self.timestamp,

            'previous_hash': self.previous_hash,

            'nonce': self.nonce

        }, sort_keys=True)

        return hashlib.sha256(block_string.encode()).hexdigest()

    def mine_block(self, difficulty):

        """

        Реализация алгоритма Proof of Work

        """

        target = "0" * difficulty

        while self.hash[:difficulty] != target:

            self.nonce += 1

            self.hash = self.compute_hash()

        print(f"Блок добыт: {self.hash}")

Метод compute_hash создает уникальную цифровую подпись блока. Использование параметра sort_keys=True обеспечивает детерминированность — одинаковые данные всегда дают одинаковый хеш.

Диаграмма показывает основные поля (index, data, timestamp и др.) и методы (compute_hash, mine_block) класса Block. Такой формат помогает визуально представить структуру данных в блокчейне на Python.

Генезис-блок и добавление новых блоков

Теперь создадим класс Blockchain, который будет управлять цепочкой блоков:

class Blockchain:

    def __init__(self):

        self.chain = []

        self.difficulty = 2  # Сложность майнинга

        self.pending_transactions = []

        self.mining_reward = 100

        self.create_genesis_block()

   

    def create_genesis_block(self):

        """

        Создает первый блок в цепи (генезис-блок)

        """

        genesis_block = Block(0, "Genesis Block", time(), "0")

        genesis_block.mine_block(self.difficulty)

        self.chain.append(genesis_block)

   

    def get_latest_block(self):

        return self.chain[-1]

   

    def add_transaction(self, transaction):

        self.pending_transactions.append(transaction)

   

    def mine_pending_transactions(self, mining_reward_address):

        """

        Добывает новый блок с ожидающими транзакциями

        """

        reward_transaction = {

            'from': None,

            'to': mining_reward_address,

            'amount': self.mining_reward

        }

        self.pending_transactions.append(reward_transaction)

       

        block = Block(

            len(self.chain),

            self.pending_transactions,

            time(),

            self.get_latest_block().hash

        )

       

        block.mine_block(self.difficulty)

        self.chain.append(block)

        self.pending_transactions = []

Финальный код и проверка цепочки

Для обеспечения целостности блокчейна необходим механизм валидации:

def is_chain_valid(self):

    """

    Проверяет целостность всей цепочки блоков

    """

    for i in range(1, len(self.chain)):

        current_block = self.chain[i]

        previous_block = self.chain[i - 1]

       

        # Проверяем корректность хеша текущего блока

        if current_block.hash != current_block.compute_hash():

            return False

       

        # Проверяем связь с предыдущим блоком

        if current_block.previous_hash != previous_block.hash:

            return False

   

    return True

def get_balance(self, address):

    """

    Вычисляет баланс для указанного адреса

    """

    balance = 0

   

    for block in self.chain:

        for transaction in block.data:

            if isinstance(transaction, dict):

                if transaction.get('from') == address:

                    balance -= transaction.get('amount', 0)

                if transaction.get('to') == address:

                    balance += transaction.get('amount', 0)

   

    return balance

Теперь мы можем протестировать наш блокчейн:

# Создаем блокчейн

my_blockchain = Blockchain()

# Добавляем транзакции

my_blockchain.add_transaction({'from': 'Alice', 'to': 'Bob', 'amount': 50})

my_blockchain.add_transaction({'from': 'Bob', 'to': 'Charlie', 'amount': 25})

# Майним блок

my_blockchain.mine_pending_transactions('Miner1')

# Проверяем балансы

print(f"Баланс Bob: {my_blockchain.get_balance('Bob')}")

print(f"Валидность цепи: {my_blockchain.is_chain_valid()}")

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

Реализация API для блокчейна на Python

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

Иллюстрация показывает, как пользователь взаимодействует с блокчейн-приложением через Flask API: от отправки запроса до обработки логики и возврата ответа. Это упрощает понимание архитектуры распределённого приложения.

Обзор Flask: зачем нужен

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

Основные преимущества Flask для блокчейн-проектов:

• Минимальная настройка и быстрый старт.
• Встроенная поддержка JSON для обмена данными.
• Простая маршрутизация запросов.
• Возможность легкого масштабирования.

Начнем с создания веб-интерфейса для нашего блокчейна:

from flask import Flask, jsonify, request

import requests

from urllib.parse import urlparse

app = Flask(__name__)

# Создаем экземпляр нашего блокчейна

blockchain = Blockchain()

# Список узлов сети (для распределенного блокчейна)

nodes = set()

Методы API: GET /chain, POST /add_transaction, GET /mine

Наш API должен предоставлять базовую функциональность для работы с блокчейном. Реализуем ключевые endpoints:

Получение всей цепочки блоков:

@app.route('/chain', methods=['GET'])

def get_chain():

    """

    Возвращает полную цепочку блоков

    """

    chain_data = []

    for block in blockchain.chain:

        chain_data.append({

            'index': block.index,

            'data': block.data,

            'timestamp': block.timestamp,

            'previous_hash': block.previous_hash,

            'hash': block.hash,

            'nonce': block.nonce

        })

   

    return jsonify({

        'length': len(chain_data),

        'chain': chain_data,

        'valid': blockchain.is_chain_valid()

    }), 200

Добавление новой транзакции:

@app.route('/add_transaction', methods=['POST'])

def add_transaction():

    """

    Добавляет новую транзакцию в пул ожидающих

    """

    transaction_data = request.get_json()

   

    required_fields = ['from', 'to', 'amount']

    if not all(field in transaction_data for field in required_fields):

        return jsonify({'error': 'Отсутствуют обязательные поля'}), 400

   

    blockchain.add_transaction(transaction_data)

   

    return jsonify({

        'message': 'Транзакция добавлена в пул',

        'transaction': transaction_data

    }), 201

Майнинг нового блока:

@app.route('/mine', methods=['GET'])

def mine_block():

    """

    Запускает процесс майнинга нового блока

    """

    if not blockchain.pending_transactions:

        return jsonify({'message': 'Нет транзакций для майнинга'}), 400

   

    # Майним новый блок

    last_block = blockchain.get_latest_block()

    blockchain.mine_pending_transactions('miner_address')

   

    new_block = blockchain.get_latest_block()

   

    return jsonify({

        'message': 'Новый блок добыт успешно',

        'index': new_block.index,

        'hash': new_block.hash,

        'previous_hash': new_block.previous_hash,

        'timestamp': new_block.timestamp

    }), 200

Проверка баланса:

@app.route('/balance/

Пример запроса и ответа

Давайте протестируем наш API с помощью curl команд:

Получение текущей цепочки:

curl -X GET http://localhost:5000/chain

Ответ:

{

  "length": 1,

  "chain": [

    {

      "index": 0,

      "data": "Genesis Block",

      "timestamp": 1636153236.7,

      "previous_hash": "0",

      "hash": "000a1b2c3d4e5f...",

      "nonce": 142

    }

  ],

  "valid": true

}

Добавление новой транзакции:

curl -X POST http://localhost:5000/add_transaction \

  -H "Content-Type: application/json" \

  -d '{"from": "Alice", "to": "Bob", "amount": 50}'

Майнинг блока:

curl -X GET http://localhost:5000/mine

Запуск сервера:

if __name__ == '__main__':

    app.run(host='0.0.0.0', port=5000, debug=True)

Теперь наш блокчейн доступен через веб-интерфейс и может обрабатывать запросы от внешних приложений. Но что если мы хотим работать не с собственным блокчейном, а с уже существующими сетями вроде Bitcoin или Ethereum? Для этого нам понадобятся специализированные библиотеки и инструменты.

Как работать с реальными блокчейнами (Bitcoin, Ethereum)

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

Обзор популярных библиотек: bitcoinlib, web3.py, eth_account

Экосистема Python включает специализированные библиотеки для работы с основными блокчейн-протоколами:

bitcoinlib — комплексная библиотека для работы с Bitcoin и другими криптовалютами на основе UTXO-модели. Она предоставляет высокоуровневый интерфейс для создания кошельков, формирования транзакций и взаимодействия с различными Bitcoin-сетями (mainnet, testnet, regtest).

web3.py — официальная Python-библиотека для взаимодействия с Ethereum. Она позволяет подключаться к узлам Ethereum, выполнять вызовы смарт-контрактов, отправлять транзакции и отслеживать события блокчейна.

eth_account — специализированная библиотека для работы с Ethereum-аккаунтами, включая создание приватных ключей, подпись транзакций и восстановление адресов из подписей.

Установка необходимых зависимостей:

pip install bitcoinlib web3 eth-account requests

Пример: создание кошелька и отправка транзакции с помощью bitcoinlib

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

from bitcoinlib.wallets import Wallet

from bitcoinlib.services.services import Service

def create_bitcoin_wallet():

    """

    Создает новый Bitcoin-кошелек для testnet

    """

    try:

        # Создаем кошелек для тестовой сети

        wallet = Wallet.create('my_test_wallet', network='testnet')

       

        # Получаем адрес для получения средств

        address = wallet.get_key().address

       

        print(f"Создан кошелек: {wallet.name}")

        print(f"Адрес: {address}")

        print(f"Приватный ключ: {wallet.get_key().wif}")

       

        return wallet

       

    except Exception as e:

        print(f"Ошибка создания кошелька: {e}")

        return None

def check_balance(wallet):

    """

    Проверяет баланс кошелька

    """

    try:

        wallet.scan()  # Сканируем блокчейн на предмет новых транзакций

        balance = wallet.balance()

       

        print(f"Баланс кошелька: {balance} сатоши")

        print(f"Баланс в BTC: {balance / 100000000}")

       

        return balance

       

    except Exception as e:

        print(f"Ошибка получения баланса: {e}")

        return 0

def send_transaction(wallet, to_address, amount_satoshi):

    """

    Отправляет транзакцию в сети Bitcoin

    """

    try:

        # Проверяем достаточность средств

        if wallet.balance() < amount_satoshi:

            print("Недостаточно средств для транзакции")

            return None

       

        # Создаем и отправляем транзакцию

        transaction = wallet.send_to(to_address, amount_satoshi)

       

        print(f"Транзакция отправлена!")

        print(f"ID транзакции: {transaction.txid}")

        print(f"Статус: {transaction.status}")

       

        return transaction

       

    except Exception as e:

        print(f"Ошибка отправки транзакции: {e}")

        return None

Работа с Ethereum через web3.py:

from web3 import Web3

from eth_account import Account

import json

def connect_to_ethereum():

    """

    Подключается к Ethereum-сети через Infura

    """

    # Для работы с mainnet замените на ваш Infura API ключ

    infura_url = "https://sepolia.infura.io/v3/YOUR_PROJECT_ID"

    w3 = Web3(Web3.HTTPProvider(infura_url))

   

    if w3.is_connected():

        print("Подключение к Ethereum установлено")

        print(f"Последний блок: {w3.eth.block_number}")

        return w3

    else:

        print("Не удалось подключиться к Ethereum")

        return None

def create_ethereum_account():

    """

    Создает новый Ethereum-аккаунт

    """

    account = Account.create()

   

    print(f"Адрес: {account.address}")

    print(f"Приватный ключ: {account.key.hex()}")

   

    return account

def get_eth_balance(w3, address):

    """

    Получает баланс ETH для указанного адреса

    """

    balance_wei = w3.eth.get_balance(address)

    balance_eth = w3.from_wei(balance_wei, 'ether')

   

    print(f"Баланс {address}: {balance_eth} ETH")

    return balance_eth

def send_eth_transaction(w3, from_account, to_address, amount_eth):

    """

    Отправляет ETH-транзакцию

    """

    try:

        # Получаем nonce для аккаунта

        nonce = w3.eth.get_transaction_count(from_account.address)

       

        # Формируем транзакцию

        transaction = {

            'to': to_address,

            'value': w3.to_wei(amount_eth, 'ether'),

            'gas': 21000,

            'gasPrice': w3.to_wei('20', 'gwei'),

            'nonce': nonce,

        }

       

        # Подписываем транзакцию

        signed_txn = w3.eth.account.sign_transaction(transaction, from_account.key)

       

        # Отправляем в сеть

        tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)

       

        print(f"Транзакция отправлена: {tx_hash.hex()}")

        return tx_hash.hex()

       

    except Exception as e:

        print(f"Ошибка отправки транзакции: {e}")

        return None

Что ещё можно: подписывать данные, проверять баланс, отслеживать статус

Библиотеки Python открывают широкие возможности для блокчейн-аналитики и автоматизации:

Мониторинг транзакций в реальном времени:

def monitor_address(w3, address):

    """

    Отслеживает новые транзакции для указанного адреса

    """

    latest_block = w3.eth.block_number

   

    while True:

        current_block = w3.eth.block_number

       

        if current_block > latest_block:

            block = w3.eth.get_block(current_block, full_transactions=True)

           

            for tx in block.transactions:

                if tx['to'] == address or tx['from'] == address:

                    print(f"Новая транзакция для {address}: {tx['hash'].hex()}")

           

            latest_block = current_block

       

        time.sleep(15)  # Проверяем каждые 15 секунд

Взаимодействие со смарт-контрактами:

def interact_with_contract(w3, contract_address, abi, function_name, *args):

    """

    Вызывает функцию смарт-контракта

    """

    contract = w3.eth.contract(address=contract_address, abi=abi)

    result = contract.functions[function_name](*args).call()

   

    print(f"Результат вызова {function_name}: {result}")

    return result

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

Примеры полезных задач, которые можно решить с помощью Python и блокчейна

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

Отслеживание транзакций и построение графов

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

import networkx as nx

import matplotlib.pyplot as plt

from web3 import Web3

import pandas as pd

class TransactionGraphAnalyzer:

    def __init__(self, w3_connection):

        self.w3 = w3_connection

        self.graph = nx.DiGraph()

        self.transactions = []

   

    def collect_transactions(self, address, depth=3):

        """

        Собирает транзакции для указанного адреса с заданной глубиной

        """

        visited = set()

        to_process = [(address, 0)]

       

        while to_process:

            current_address, current_depth = to_process.pop(0)

           

            if current_depth >= depth or current_address in visited:

                continue

               

            visited.add(current_address)

           

            # Получаем последние блоки для анализа

            latest_block = self.w3.eth.block_number

            for block_num in range(latest_block - 100, latest_block):

                try:

                    block = self.w3.eth.get_block(block_num, full_transactions=True)

                   

                    for tx in block.transactions:

                        if tx['from'] == current_address or tx['to'] == current_address:

                            self.process_transaction(tx)

                           

                            # Добавляем связанные адреса для дальнейшего анализа

                            next_address = tx['to'] if tx['from'] == current_address else tx['from']

                            if next_address and next_address not in visited:

                                to_process.append((next_address, current_depth + 1))

                               

                except Exception as e:

                    print(f"Ошибка обработки блока {block_num}: {e}")

   

    def process_transaction(self, tx):

        """

        Обрабатывает транзакцию и добавляет в граф

        """

        if tx['from'] and tx['to']:

            value_eth = self.w3.from_wei(tx['value'], 'ether')

           

            self.graph.add_edge(

                tx['from'],

                tx['to'],

                value=float(value_eth),

                tx_hash=tx['hash'].hex(),

                gas_used=tx['gas']

            )

           

            self.transactions.append({

                'from': tx['from'],

                'to': tx['to'],

                'value': float(value_eth),

                'hash': tx['hash'].hex(),

                'timestamp': tx['blockNumber']

            })

   

    def visualize_graph(self):

        """

        Создает визуализацию графа транзакций

        """

        plt.figure(figsize=(15, 10))

       

        # Позиционирование узлов

        pos = nx.spring_layout(self.graph, k=1, iterations=50)

       

        # Размер узлов зависит от количества транзакций

        node_sizes = [self.graph.degree(node) * 100 for node in self.graph.nodes()]

       

        # Толщина ребер зависит от суммы транзакций

        edge_weights = [self.graph[u][v]['value'] for u, v in self.graph.edges()]

       

        nx.draw(self.graph, pos,

                node_size=node_sizes,

                width=[w/max(edge_weights)*5 for w in edge_weights],

                with_labels=False,

                node_color='lightblue',

                edge_color='gray',

                arrows=True)

       

        plt.title("Граф транзакций")

        plt.show()

Проверка NFT или смарт-контрактов

NFT-верификация стала критически важной задачей в условиях роста рынка цифровых активов.

Иллюстрация отображает молодого разработчика, работающего с NFT-системами на Python. Визуальные элементы (сертификат, график, NFT-значки) подчеркивают тему верификации цифровых активов и анализа данных.

Python позволяет создавать автоматизированные системы проверки подлинности токенов:

class NFTVerifier:

    def __init__(self, w3_connection):

        self.w3 = w3_connection

        # Стандартный ABI для ERC-721 токенов

        self.erc721_abi = [

            {

                "constant": True,

                "inputs": [{"name": "_tokenId", "type": "uint256"}],

                "name": "tokenURI",

                "outputs": [{"name": "", "type": "string"}],

                "type": "function"

            },

            {

                "constant": True,

                "inputs": [{"name": "_tokenId", "type": "uint256"}],

                "name": "ownerOf",

                "outputs": [{"name": "", "type": "address"}],

                "type": "function"

            }

        ]

   

    def verify_nft_ownership(self, contract_address, token_id, claimed_owner):

        """

        Проверяет владельца NFT-токена

        """

        try:

            contract = self.w3.eth.contract(

                address=contract_address,

                abi=self.erc721_abi

            )

           

            actual_owner = contract.functions.ownerOf(token_id).call()

           

            verification_result = {

                'token_id': token_id,

                'contract_address': contract_address,

                'claimed_owner': claimed_owner,

                'actual_owner': actual_owner,

                'is_valid': actual_owner.lower() == claimed_owner.lower()

            }

           

            return verification_result

           

        except Exception as e:

            return {'error': f"Ошибка верификации: {e}"}

   

    def get_nft_metadata(self, contract_address, token_id):

        """

        Получает метаданные NFT

        """

        try:

            contract = self.w3.eth.contract(

                address=contract_address,

                abi=self.erc721_abi

            )

           

            token_uri = contract.functions.tokenURI(token_id).call()

           

            # Если URI указывает на IPFS, получаем данные

            if token_uri.startswith('ipfs://'):

                ipfs_hash = token_uri.replace('ipfs://', '')

                metadata_url = f"https://ipfs.io/ipfs/{ipfs_hash}"

               

                response = requests.get(metadata_url)

                if response.status_code == 200:

                    return response.json()

           

            return {'token_uri': token_uri}

           

        except Exception as e:

            return {'error': f"Ошибка получения метаданных: {e}"}

Диаграмма показывает процесс верификации владения NFT через контракт ERC-721: запрос метода ownerOf(tokenId), получение адреса владельца и сравнение с заявленным. Это помогает понять, как реализуется проверка подлинности токена.

Генерация хеша и подписи файлов

Система цифровых подписей на основе блокчейна может обеспечить неопровержимое доказательство существования документа в определенный момент времени:

import hashlib

from eth_account import Account

from datetime import datetime

import json

class DocumentTimestamping:

    def __init__(self, private_key=None):

        if private_key:

            self.account = Account.from_key(private_key)

        else:

            self.account = Account.create()

            print(f"Создан новый аккаунт: {self.account.address}")

   

    def generate_file_hash(self, file_path):

        """

        Генерирует SHA-256 хеш файла

        """

        sha256_hash = hashlib.sha256()

       

        with open(file_path, "rb") as f:

            for chunk in iter(lambda: f.read(4096), b""):

                sha256_hash.update(chunk)

       

        return sha256_hash.hexdigest()

   

    def create_timestamp_record(self, file_path, description=""):

        """

        Создает запись с временной меткой для файла

        """

        file_hash = self.generate_file_hash(file_path)

        timestamp = datetime.now().isoformat()

       

        record = {

            'file_hash': file_hash,

            'timestamp': timestamp,

            'description': description,

            'signer': self.account.address

        }

       

        # Создаем подпись записи

        message_hash = hashlib.sha256(json.dumps(record, sort_keys=True).encode()).digest()

        signature = self.account.sign_message_hash(message_hash)

       

        record['signature'] = signature.signature.hex()

       

        return record

   

    def verify_timestamp_record(self, record, file_path):

        """

        Проверяет подлинность записи с временной меткой

        """

        # Проверяем хеш файла

        current_hash = self.generate_file_hash(file_path)

        if current_hash != record['file_hash']:

            return {'valid': False, 'reason': 'Файл был изменен'}

       

        # Проверяем подпись

        record_copy = record.copy()

        signature = record_copy.pop('signature')

       

        message_hash = hashlib.sha256(json.dumps(record_copy, sort_keys=True).encode()).digest()

       

        try:

            recovered_address = Account.recover_message_hash(message_hash, signature=signature)

            if recovered_address.lower() == record['signer'].lower():

                return {'valid': True, 'timestamp': record['timestamp']}

            else:

                return {'valid': False, 'reason': 'Неверная подпись'}

        except:

            return {'valid': False, 'reason': 'Ошибка верификации подписи'}

# Пример использования

timestamper = DocumentTimestamping()

# Создаем временную метку для документа

record = timestamper.create_timestamp_record('important_document.pdf', 'Контракт с поставщиком')

print(f"Создана запись: {record}")

# Проверяем запись

verification = timestamper.verify_timestamp_record(record, 'important_document.pdf')

print(f"Результат проверки: {verification}")

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

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

Заключение

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

• Python позволяет создавать собственный блокчейн. Это хороший выбор для обучения и прототипирования.
• Основные элементы блокчейна — это блоки, хеши, цепочка, и алгоритм консенсуса.
• Flask и web3.py позволяют развивать проекты в сторону API и работы с Ethereum.
• С помощью bitcoinlib можно работать с Bitcoin-сетями, включая отправку транзакций.
• NFT, подпись файлов, верификация и аналитика — всё это тоже можно реализовать на Python.

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