Python для блокчейна: создание приложений от теории до токена

python -m venv blockchain_env
source blockchain_env/bin/activate # для Linux/Mac
blockchain_env\Scripts\activate # для Windows

pip install hashlib requests flask

pip install web3

import hashlib

def create_hash(data):
return hashlib.sha256(data.encode()).hexdigest()

test_data = "Мой первый блокчейн на Python"
hash_result = create_hash(test_data)
print(f"Данные: {test_data}")
print(f"Хеш: {hash_result}")

import hashlib
import time
import json
from datetime import datetime

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

def compute_hash(self):
"""
Создает SHA-256 хеш блока
"""
block_string = json.dumps(self.__dict__, sort_keys=True)
return hashlib.sha256(block_string.encode()).hexdigest()

class Blockchain:
# Сложность алгоритма майнинга
difficulty = 2

def __init__(self):
self.unconfirmed_transactions = []
self.chain = []
self.create_genesis_block()

def create_genesis_block(self):
"""
Генерирует первый блок цепочки с произвольным предыдущим хешем
"""
genesis_block = Block(0, [], str(datetime.now()), "0")
genesis_block.hash = genesis_block.compute_hash()
self.chain.append(genesis_block)

@property
def last_block(self):
"""
Возвращает последний блок в цепочке
"""
return self.chain[-1]

def proof_of_work(self, block):
"""
Функция, которая пытается подобрать значение nonce, чтобы получить хеш,
удовлетворяющий условиям сложности майнинга
"""
block.nonce = 0
computed_hash = block.compute_hash()
while not computed_hash.startswith('0' * Blockchain.difficulty):
block.nonce += 1
computed_hash = block.compute_hash()
return computed_hash

def add_block(self, block, proof):
"""
Добавляет блок в цепочку после проверки
"""
previous_hash = self.last_block.hash

# Проверка корректности предыдущего хеша
if previous_hash != block.previous_hash:
return False

# Проверка валидности доказательства работы
if not self.is_valid_proof(block, proof):
return False

block.hash = proof
self.chain.append(block)
return True

def is_valid_proof(self, block, block_hash):
"""
Проверяет, удовлетворяет ли хеш требованиям сложности майнинга
"""
return (block_hash.startswith('0' * Blockchain.difficulty) and
block_hash == block.compute_hash())

def add_new_transaction(self, transaction):
"""
Добавляет новую транзакцию в пул неподтвержденных транзакций
"""
self.unconfirmed_transactions.append(transaction)

def mine(self):
"""
Интерфейс для добавления ожидающих транзакций в блокчейн
"""
if not self.unconfirmed_transactions:
return False

last_block = self.last_block

new_block = Block(index=last_block.index + 1,
transactions=self.unconfirmed_transactions,
timestamp=str(datetime.now()),
previous_hash=last_block.hash)

proof = self.proof_of_work(new_block)
self.add_block(new_block, proof)
self.unconfirmed_transactions = []
return new_block.index

# Инициализация блокчейна
blockchain = Blockchain()

# Добавление транзакций
blockchain.add_new_transaction({
"sender": "Alice",
"recipient": "Bob",
"amount": 5
})
blockchain.add_new_transaction({
"sender": "Bob",
"recipient": "Charlie",
"amount": 2
})

# Майнинг блока (добавление транзакций в цепочку)
print("Начинаем майнинг...")
block_index = blockchain.mine()
print(f"Блок #{block_index} успешно создан!")

# Проверка состояния блокчейна
print(f"Длина цепочки: {len(blockchain.chain)}")
print(f"Последний блок: {json.dumps(blockchain.last_block.__dict__, indent=4)}")

# Установка
# pip install web3

from web3 import Web3

# Подключение к Ethereum через Infura
infura_url = "https://mainnet.infura.io/v3/YOUR_INFURA_KEY"
web3 = Web3(Web3.HTTPProvider(infura_url))

# Проверка соединения
print(f"Подключено к Ethereum: {web3.is_connected()}")

# Получение текущего номера блока
print(f"Текущий блок: {web3.eth.block_number}")

# Получение баланса адреса
address = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
balance_wei = web3.eth.get_balance(address)
balance_eth = web3.from_wei(balance_wei, "ether")
print(f"Баланс адреса {address}: {balance_eth} ETH")

# Загрузка смарт-контракта
# ABI (Application Binary Interface) описывает интерфейс контракта
contract_abi = [{"inputs":[],"name":"retrieve","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"num","type":"uint256"}],"name":"store","outputs":[],"stateMutability":"nonpayable","type":"function"}]
contract_address = "0x1234567890123456789012345678901234567890"

# Создание экземпляра контракта
contract = web3.eth.contract(address=contract_address, abi=contract_abi)

# Вызов метода контракта (чтение данных)
stored_value = contract.functions.retrieve().call()
print(f"Сохраненное значение: {stored_value}")

# Отправка транзакции (изменение состояния)
account = "0xYOUR_ACCOUNT_ADDRESS"
private_key = "YOUR_PRIVATE_KEY"

# Создание транзакции
nonce = web3.eth.get_transaction_count(account)
tx = contract.functions.store(100).build_transaction({
'chainId': 1, # ID основной сети Ethereum
'gas': 2000000,
'gasPrice': web3.to_wei('50', 'gwei'),
'nonce': nonce,
})

# Подписание и отправка транзакции
signed_tx = web3.eth.account.sign_transaction(tx, private_key)
tx_hash = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
print(f"Транзакция отправлена: {tx_hash.hex()}")

# Ожидание подтверждения транзакции
receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
print(f"Транзакция подтверждена в блоке {receipt.blockNumber}")

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

contract SimpleToken {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;

mapping(address => uint256) private balances;
mapping(address => mapping(address => uint256)) private allowances;

event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);

constructor(string memory _name, string memory _symbol, uint8 _decimals, uint256 _initialSupply) {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _initialSupply * 10**uint256(_decimals);
balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}

function balanceOf(address account) public view returns (uint256) {
return balances[account];
}

function transfer(address recipient, uint256 amount) public returns (bool) {
require(balances[msg.sender] >= amount, "Insufficient balance");

balances[msg.sender] -= amount;
balances[recipient] += amount;
emit Transfer(msg.sender, recipient, amount);
return true;
}

function allowance(address owner, address spender) public view returns (uint256) {
return allowances[owner][spender];
}

function approve(address spender, uint256 amount) public returns (bool) {
allowances[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}

function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
require(balances[sender] >= amount, "Insufficient balance");
require(allowances[sender][msg.sender] >= amount, "Insufficient allowance");

balances[sender] -= amount;
balances[recipient] += amount;
allowances[sender][msg.sender] -= amount;
emit Transfer(sender, recipient, amount);
return true;
}
}

import json
from web3 import Web3
from solcx import compile_source, install_solc

# Установка компилятора Solidity
install_solc('0.8.0')

# Компиляция контракта
with open('SimpleToken.sol', 'r') as file:
contract_source_code = file.read()

compiled_sol = compile_source(
contract_source_code,
output_values=['abi', 'bin'],
solc_version='0.8.0'
)

contract_id, contract_interface = compiled_sol.popitem()
abi = contract_interface['abi']
bytecode = contract_interface['bin']

# Подключение к локальной тестовой сети (Ganache)
w3 = Web3(Web3.HTTPProvider('http://127.0.0.1:8545'))

# Проверка соединения
if not w3.is_connected():
print("Не удалось подключиться к Ethereum")
exit()

# Получение аккаунта для развертывания
account = w3.eth.accounts[0]
w3.eth.default_account = account

# Создание контракта
SimpleToken = w3.eth.contract(abi=abi, bytecode=bytecode)

# Параметры токена
token_name = "My Python Token"
token_symbol = "MPT"
token_decimals = 18
initial_supply = 1000000 # 1 миллион токенов

# Развертывание контракта
print(f"Развертывание токена {token_name}...")
tx_hash = SimpleToken.constructor(
token_name, 
token_symbol, 
token_decimals, 
initial_supply
).transact()

# Ожидание завершения транзакции
tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print(f"Токен развернут по адресу: {tx_receipt.contractAddress}")

# Сохранение ABI для дальнейшего использования
with open('token_abi.json', 'w') as file:
json.dump(abi, file)

# Создание экземпляра контракта для взаимодействия
token_contract = w3.eth.contract(
address=tx_receipt.contractAddress,
abi=abi
)

# Проверка информации о токене
print(f"Название: {token_contract.functions.name().call()}")
print(f"Символ: {token_contract.functions.symbol().call()}")
print(f"Десятичные знаки: {token_contract.functions.decimals().call()}")
total_supply = token_contract.functions.totalSupply().call()
print(f"Общее количество: {total_supply / (10**token_decimals)} {token_symbol}")

# Проверка баланса владельца
owner_balance = token_contract.functions.balanceOf(account).call()
print(f"Баланс {account}: {owner_balance / (10**token_decimals)} {token_symbol}")

def transfer_tokens(w3, token_contract, sender, recipient, amount, decimals):
"""
Переводит токены от отправителя к получателю
"""
# Конвертация суммы в минимальные единицы токена
amount_in_smallest_units = int(amount * (10**decimals))

# Получение текущего баланса для проверки
sender_balance = token_contract.functions.balanceOf(sender).call()

if sender_balance < amount_in_smallest_units:
print(f"Недостаточно токенов. Баланс: {sender_balance / (10**decimals)}")
return False

# Создание транзакции
tx_hash = token_contract.functions.transfer(
recipient, 
amount_in_smallest_units
).transact({'from': sender})

# Ожидание завершения транзакции
tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

# Проверка успешности транзакции
if tx_receipt.status == 1:
print(f"Успешно отправлено {amount} токенов от {sender} к {recipient}")
# Обновленные балансы
new_sender_balance = token_contract.functions.balanceOf(sender).call()
new_recipient_balance = token_contract.functions.balanceOf(recipient).call()
print(f"Новый баланс отправителя: {new_sender_balance / (10**decimals)}")
print(f"Новый баланс получателя: {new_recipient_balance / (10**decimals)}")
return True
else:
print("Транзакция не удалась")
return False

# Использование функции для перевода токенов
recipient = w3.eth.accounts[1] # Другой аккаунт в тестовой сети
transfer_amount = 1000 # Перевести 1000 токенов

transfer_tokens(
w3, 
token_contract, 
account, # отправитель (владелец токенов)
recipient, 
transfer_amount, 
token_decimals
)

from web3 import Web3
from eth_account import Account
import os

# Загрузка приватного ключа из безопасного источника
private_key = os.environ.get("PRIVATE_KEY") # Никогда не храните ключи в коде!
account = Account.from_key(private_key)

# Подключение к основной сети через Infura
infura_url = f"https://mainnet.infura.io/v3/{os.environ.get('INFURA_KEY')}"
w3 = Web3(Web3.HTTPProvider(infura_url))

# Проверка подключения
if not w3.is_connected():
print("Не удалось подключиться к Ethereum")
exit()

# Развертывание контракта с подписанием транзакции
SimpleToken = w3.eth.contract(abi=abi, bytecode=bytecode)
construct_txn = SimpleToken.constructor(
token_name, 
token_symbol, 
token_decimals, 
initial_supply
).build_transaction({
'from': account.address,
'nonce': w3.eth.get_transaction_count(account.address),
'gas': 2000000,
'gasPrice': w3.to_wei('50', 'gwei')
})

# Подписание транзакции
signed_txn = w3.eth.account.sign_transaction(construct_txn, private_key)

# Отправка транзакции
tx_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
print(f"Транзакция отправлена: {tx_hash.hex()}")

# Ожидание подтверждения (может занять несколько минут)
tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
print(f"Токен развернут по адресу: {tx_receipt.contractAddress}")