Привет, Хабр!
Сегодня я расскажу вам о библиотеке 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, которое будет представлять собой простой децентрализованный рынок для обмена токенов. Это приложение позволит пользователям обменивать один токен на другой, отслеживать свои балансы и взаимодействовать с смарт-контрактами.
Приложение будет состоять из следующих компонентов:
Смарт-контракт: Контракт, который управляет логикой обмена токенов.
Frontend: Интерфейс пользователя для взаимодействия с контрактом.
Код на 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>Как запустить?
Смарт-контракт: Разворачиваем смарт-контракт на тестовой сети Ethereum с помощью Remix или того же Truffle.
Backend: Убедитесь, что ваш код на Python работает с правильными адресами смарт-контракта и кошельком.
Frontend: Заменяем
0xYourContractAddressна адрес смарт-контракта и добавляем ABI контракта в JS.
Подробнее с библиотекой можно ознакомиться здесь.
В заключение упомяну об открытых уроках, которые пройдут в октябре в рамках курса «Разработка децентрализованных приложений»:
3 октября: Применение RUST при создании децентрализованных приложений (Dapps). Запись по ссылке
23 октября: Применение блокчейнов при создании децентрализованных приложений (DApps). Запись по ссылке