Привет, Хабр!

Сегодня я расскажу вам о библиотеке dApp для Python — мощном инструменте для создания децентрализованных приложений на базе блокчейна. Она предлагает все необходимые функции для взаимодействия со смарт-контрактами, управления данными и обеспечения безопасности приложений. Итак, разберемся, что же она может!

Установим библиотеку, благо, это делается просто:

pip install dapp

Основные функции библиотеки dApp

Основная задача dApp заключается в взаимодействие с блокчейном. Библиотека позволяет работать со смарт-контрактами, создавая и отправляя транзакции.

Пример создания и отправки транзакции:

from dapp import Blockchain, Contract

# Инициализация соединения с блокчейном
blockchain = Blockchain('https://your-blockchain-node.com')

# Загрузка контракта
contract = Contract('0xYourContractAddress', blockchain)

# Создание транзакции
tx_data = {
    'from': '0xYourWalletAddress',
    'to': '0xRecipientAddress',
    'value': 1000000000000000000,  # 1 ETH в wei
}

# Отправка транзакции
tx_hash = contract.send_transaction(tx_data)
print(f'Transaction sent: {tx_hash}')

Этот код инициализирует соединение с блокчейном, загружает смарт-контракт и создает транзакцию.

Подписка на события

Смарт-контракты могут генерировать события, которые приложение может отслеживать. Например, вот как подписаться на событие "Transfer":

def handle_transfer(event):
    print(f'Transfer event detected: {event}')

contract.on('Transfer', handle_transfer)

# Бесконечный цикл для ожидания событий
import time
while True:
    time.sleep(1)

Теперь приложение будет реагировать на каждое событие Transfer, которое генерируется смарт-контрактом.

Хранение данных с IPFS

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

from dapp import IPFS

# Инициализация IPFS
ipfs = IPFS()

# Загрузка файла
file_hash = ipfs.upload('path/to/your/file.txt')
print(f'File uploaded to IPFS with hash: {file_hash}')

# Получение файла
file_content = ipfs.download(file_hash)
print(f'File content: {file_content}')

Так можно загружать файлы в IPFS и извлекать их по хэшу.

Безопасность

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

from dapp import Auth

# Инициализация аутентификации
auth = Auth()

# Вход пользователя
user_address = auth.login('username', 'password')
print(f'User logged in: {user_address}')

Теперь пользователи могут безопасно входить в приложение.

Работа с оракулами

Иногда приложения требуют доступа к внешним данным. Здесь на помощь приходят оракулы, например, Chainlink.

Пример запроса данных из оракула:

from dapp import Oracle

# Инициализация оракула
oracle = Oracle('0xOracleContractAddress')

# Запрос цены ETH/USD
price = oracle.request_data('ETH/USD')
print(f'Current ETH price: {price}')

Таким образом, можно получить актуальные данные о ценах и использовать их в своем приложении.

Многофункциональность

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

from dapp import Blockchain

# Инициализация блокчейна Ethereum
eth_blockchain = Blockchain('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID')

# Инициализация Binance Smart Chain
bsc_blockchain = Blockchain('https://bsc-dataseed.binance.org/')

# Пример получения баланса ETH
eth_balance = eth_blockchain.get_balance('0xYourEthereumAddress')
print(f'ETH Balance: {eth_balance}')

# Пример получения баланса BNB
bsc_balance = bsc_blockchain.get_balance('0xYourBinanceAddress')
print(f'BNB Balance: {bsc_balance}')

Утилиты для тестирования

У dApp есть встроенные функции для имитации транзакций, проверки состояния блокчейна и создания тестовых учетных записей. Вот как можно протестировать транзакцию:

from dapp import TestBlockchain

# Инициализация тестового блокчейна
test_blockchain = TestBlockchain()

# Создание тестовой учетной записи
test_account = test_blockchain.create_account()

# Имитация транзакции
test_tx = {
    'from': test_account.address,
    'to': '0xSomeRecipientAddress',
    'value': 500000000000000000,  # 0.5 ETH
}

# Подтверждение транзакции
test_tx_receipt = test_blockchain.send_transaction(test_tx)
print(f'Test Transaction Receipt: {test_tx_receipt}')

Таким образом можно тестировать транзакции в изолированном окружении.

Взаимодействие с DeFi-протоколами

Библиотека dApp поддерживает интеграцию с DeFi-протоколами. Например, можно работать с Uniswap:

from dapp import Uniswap

# Инициализация Uniswap
uniswap = Uniswap('0xUniswapRouterAddress')

# Обмен токенов
swap_tx = {
    'from': '0xYourWalletAddress',
    'to': '0xTokenToSwapAddress',
    'amount': 1000000000000000000,  # 1 токен в wei
}

# Выполнение обмена
swap_receipt = uniswap.swap_tokens(swap_tx)
print(f'Transaction Receipt: {swap_receipt}')

Управление смарт-контрактами

С помощью dApp можно управлять жизненным циклом смарт-контрактов: развертыванием, обновлением и удалением. Пример развертывания контракта:

from dapp import ContractManager

# Инициализация менеджера контрактов
contract_manager = ContractManager()

# Развертывание нового контракта
contract_address = contract_manager.deploy('MySmartContract', 'ConstructorArgument')
print(f'Contract deployed at: {contract_address}')

Аналитика и мониторинг

И, наконец, функции для мониторинга и аналитики помогут отслеживать состояние приложения в реальном времени:

from dapp import Analytics

# Инициализация аналитики
analytics = Analytics()

# Получение статистики по транзакциям
tx_stats = analytics.get_transaction_stats('0xYourWalletAddress')
print(f'Transaction Stats: {tx_stats}')

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

Пример реализации

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

Приложение будет состоять из следующих компонентов:

1. Смарт-контракт: Контракт, который управляет логикой обмена токенов.

2. Frontend: Интерфейс пользователя для взаимодействия с контрактом.

3. Код на Python: Серверная часть, использующая библиотеку dApp для связи с блокчейном.

Смарт-контракт:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0 ;

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
}

contract TokenExchange {
    address public token1;
    address public token2;

    event TokensSwapped(address indexed user, uint256 amountIn, uint256 amountOut);

    constructor(address _token1, address _token2) {
        token1 = _token1;
        token2 = _token2;
    }

    function swap(uint256 amountIn) external {
        require(IERC20(token1).balanceOf(msg.sender) >= amountIn, "Insufficient balance");
        
        uint256 amountOut = amountIn; // Здесь можно добавить логику для расчета количества токенов, возвращаемых в зависимости от курса.
        
        require(IERC20(token1).transferFrom(msg.sender, address(this), amountIn), "Transfer failed");
        require(IERC20(token2).transfer(msg.sender, amountOut), "Transfer failed");

        emit TokensSwapped(msg.sender, amountIn, amountOut);
    }
}

Backend часть

Cоздадим серверную часть с помощью библиотеки dApp, которая будет взаимодействовать со смарт-контрактом:

from dapp import Blockchain, Contract

# Инициализация соединения с блокчейном
blockchain = Blockchain('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID')

# Загружаем смарт-контракт
contract_address = '0xYourContractAddress'
exchange_contract = Contract(contract_address, blockchain)

def swap_tokens(user_address, amount_in):
    tx_data = {
        'from': user_address,
        'to': contract_address,
        'amount': amount_in,
    }
    tx_hash = exchange_contract.call('swap', tx_data)
    return tx_hash

# Пример использования функции обмена токенов
user_address = '0xYourWalletAddress'
amount_to_swap = 1000000000000000000  # 1 токен в wei
transaction_hash = swap_tokens(user_address, amount_to_swap)
print(f'Transaction sent: {transaction_hash}')

Frontend

Создадим простую HTML-страницу с JavaScript для взаимодействия с нашим dApp:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Token Exchange</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            margin: 20px;
            padding: 20px;
            border: 1px solid #ccc;
            border-radius: 5px;
            background-color: #f9f9f9;
        }
        h1 {
            color: #333;
        }
        input {
            padding: 10px;
            margin: 10px 0;
            width: 100%;
            box-sizing: border-box;
        }
        button {
            padding: 10px;
            width: 100%;
            background-color: #4CAF50;
            color: white;
            border: none;
            cursor: pointer;
        }
        button:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>

    <div>
        <h1>Token Exchange dApp</h1>
        <input placeholder="Amount to swap" id="amountIn" type="text">
        <button id="swapButton">Swap Tokens</button>
    </div>

    <script>
        document.getElementById('swapButton').onclick = function() {
            const amountIn = document.getElementById('amountIn').value;
            console.log(`Swapping ${amountIn} tokens...`);
            // логика для вызова функции обмена токенов
        };
    </script>

</body>
</html>

Как запустить?

1. Смарт-контракт: Разворачиваем смарт-контракт на тестовой сети Ethereum с помощью Remix или того же Truffle.

2. Backend: Убедитесь, что ваш код на Python работает с правильными адресами смарт-контракта и кошельком.

3. Frontend: Заменяем 0xYourContractAddress на адрес смарт-контракта и добавляем ABI контракта в JS.

Подробнее с библиотекой можно ознакомиться здесь.

В заключение упомяну об открытых уроках, которые пройдут в октябре в рамках курса «Разработка децентрализованных приложений»:

• 3 октября: Применение RUST при создании децентрализованных приложений (Dapps). Запись по ссылке

• 23 октября: Применение блокчейнов при создании децентрализованных приложений (DApps). Запись по ссылке