Криптовалютный арбитраж 2025: полное техническое руководство

# Базовая структура проекта
crypto_arbitrage/
├── bots/
│   ├── p2p_arbitrage.py
│   ├── exchange_arbitrage.py
│   └── triangular_arbitrage.py
├── data/
│   ├── database.py
│   └── cache.py
├── api/
│   ├── binance_api.py
│   ├── bybit_api.py
│   └── garantex_api.py
├── config/
│   └── settings.py
└── utils/
    ├── risk_management.py
    └── notification.py

import asyncio
import aiohttp
from decimal import Decimal

class P2PArbitrageBot:
    def __init__(self):
        self.platforms = {
            'binance': BinanceP2P(),
            'bybit': BybitP2P(),
            'garantex': GarantexP2P()
        }
        self.min_profit_threshold = Decimal('0.02')  # 2%
    
    async def scan_opportunities(self):
        while True:
            tasks = []
            for platform in self.platforms.values():
                tasks.append(platform.get_p2p_prices())
            
            all_prices = await asyncio.gather(*tasks)
            opportunities = self.find_arbitrage_opportunities(all_prices)
            
            for opportunity in opportunities:
                if self.calculate_net_profit(opportunity) > self.min_profit_threshold:
                    await self.execute_arbitrage(opportunity)
            
            await asyncio.sleep(1)  # 1 секунда между сканированиями
    
    def calculate_net_profit(self, opportunity):
        buy_price = opportunity['buy_price']
        sell_price = opportunity['sell_price']
        
        # Учитываем комиссии платформ
        platform_fees = {
            'binance': Decimal('0.001'),
            'bybit': Decimal('0.0015'), 
            'garantex': Decimal('0.002')
        }
        
        gross_profit = (sell_price - buy_price) / buy_price
        net_profit = gross_profit - platform_fees[opportunity['buy_platform']]
        net_profit -= platform_fees[opportunity['sell_platform']]
        
        return net_profit

class BinanceP2P:
    def __init__(self):
        self.base_url = "https://p2p.binance.com/bapi/c2c/v2/"
        self.session = aiohttp.ClientSession()
    
    async def get_p2p_prices(self, asset="USDT", fiat="RUB", trade_type="BUY"):
        payload = {
            "asset": asset,
            "fiat": fiat,
            "tradeType": trade_type,
            "rows": 20,
            "page": 1
        }
        
        async with self.session.post(
            f"{self.base_url}friendly/c2c/adv/search",
            json=payload
        ) as response:
            data = await response.json()
            return self.parse_prices(data)
    
    def parse_prices(self, data):
        prices = []
        for adv in data['data']:
            price = Decimal(adv['adv']['price'])
            min_amount = Decimal(adv['adv']['minSingleTransAmount'])
            max_amount = Decimal(adv['adv']['maxSingleTransAmount'])
            
            prices.append({
                'price': price,
                'min_amount': min_amount,
                'max_amount': max_amount,
                'payment_methods': adv['adv']['tradeMethods']
            })
        
        return sorted(prices, key=lambda x: x['price'])

import websockets
import json

class GarantexP2P:
    async def connect_websocket(self):
        async with websockets.connect("wss://garantex.io/api/v2/ws") as ws:
            await ws.send(json.dumps({
                "event": "subscribe",
                "streams": ["p2p_usdt_rub"]
            }))
            
            while True:
                message = await ws.recv()
                data = json.loads(message)
                yield self.process_garantex_data(data)
    
    def process_garantex_data(self, data):
        # Обработка данных Garantex
        return {
            'platform': 'garantex',
            'buy_price': Decimal(data['buy_price']),
            'sell_price': Decimal(data['sell_price']),
            'volume': Decimal(data['volume'])
        }

class RiskManager:
    def __init__(self):
        self.max_daily_loss = Decimal('0.05')  # 5%
        self.max_position_size = Decimal('0.1')  # 10% от капитала
        self.platform_limits = {
            'binance': Decimal('50000'),
            'bybit': Decimal('30000'),
            'garantex': Decimal('20000')
        }
    
    def check_opportunity(self, opportunity, current_capital):
        # Проверка лимитов платформ
        if opportunity['amount'] > self.platform_limits[opportunity['platform']]:
            return False
        
        # Проверка размера позиции
        if opportunity['amount'] > current_capital * self.max_position_size:
            return False
        
        # Проверка AML рисков
        if self.aml_check(opportunity):
            return False
        
        return True
    
    def aml_check(self, opportunity):
        # Проверка сумм на соответствие законодательству
        amount = opportunity['amount']
        
        # Лимиты для разных юрисдикций
        limits = {
            'RUB': Decimal('600000'),  # 600к руб - лимит для РФ
            'USD': Decimal('10000'),   # $10k - международный лимит
        }
        
        return amount > limits.get(opportunity['currency'], Decimal('0'))
    
    async def monitor_transactions(self):
        # Мониторинг подозрительных транзакций
        pass

class WithdrawalManager:
    def __init__(self):
        self.legal_methods = self.load_legal_methods()
        self.gray_methods = self.load_gray_methods()
    
    def legal_withdrawal(self, amount, currency):
        # Легальный вывод через банковскую систему
        if amount < Decimal('600000'):
            # Малые суммы - прямой банковский перевод
            return self.bank_transfer(amount, currency)
        else:
            # Крупные суммы - разбивка на несколько транзакций
            return self.structured_withdrawal(amount, currency)
    
    def gray_withdrawal(self, amount, currency):
        # Полулегальные методы (только для образовательных целей)
        methods = [
            self.p2p_offline(amount, currency),
            self.nominee_accounts(amount, currency),
            self.crypto_debit_cards(amount, currency)
        ]
        return methods
    
    def p2p_offline(self, amount, currency):
        # P2P с оффлайн встречей
        # ВНИМАНИЕ: высокие риски
        return {
            'method': 'p2p_offline',
            'risk_level': 'high',
            'description': 'Личная встреча с контрагентом',
            'precautions': [
                'Проверка контрагента',
                'Встреча в общественном месте',
                'Использование эскроу'
            ]
        }

class TaxOptimizer:
    def __init__(self):
        self.tax_rate = Decimal('0.13')  # 13% НДФЛ в РФ
        self.deductions = {
            'investment': Decimal('0'),  # Инвестиционные вычеты
            'professional': Decimal('0')  # Профессиональные вычеты
        }
    
    def calculate_tax(self, profit, method='standard'):
        if method == 'standard':
            return profit * self.tax_rate
        elif method == 'investment_deduction':
            taxable_profit = max(profit - self.deductions['investment'], 0)
            return taxable_profit * self.tax_rate
        elif method == 'professional_expenses':
            # Учет профессиональных расходов
            expenses = self.calculate_expenses(profit)
            taxable_profit = max(profit - expenses, 0)
            return taxable_profit * self.tax_rate
    
    def international_optimization(self, profit):
        # Использование международных схем (только для юридических лиц)
        strategies = [
            self.double_taxation_treaty(),
            self.offshore_companies(),
            self.crypto_friendly_jurisdictions()
        ]
        return strategies

class Analytics:
    def __init__(self):
        self.db = Database()
        self.metrics = {}
    
    async def track_performance(self):
        metrics = {
            'daily_profit': await self.calculate_daily_profit(),
            'success_rate': await self.calculate_success_rate(),
            'max_drawdown': await self.calculate_max_drawdown(),
            'sharpe_ratio': await self.calculate_sharpe_ratio()
        }
        
        self.metrics = metrics
        await self.alert_on_anomalies(metrics)
    
    async def generate_report(self):
        report = f"""
        Отчет по арбитражу за {datetime.now().date()}
        
        Общая прибыль: {self.metrics['daily_profit']}
        Успешных сделок: {self.metrics['success_rate']}%
        Максимальная просадка: {self.metrics['max_drawdown']}%
        Коэффициент Шарпа: {self.metrics['sharpe_ratio']}
        """
        return report

# docker-compose.yml
version: '3.8'
services:
  arbitrage-bot:
    build: .
    environment:
      - API_KEY_BINANCE=${API_KEY_BINANCE}
      - API_SECRET_BINANCE=${API_SECRET_BINANCE}
      - DATABASE_URL=postgresql://user:pass@db:5432/arbitrage
    depends_on:
      - db
      - redis
  
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=arbitrage
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
  
  redis:
    image: redis:alpine

class ComplianceManager:
    def ensure_compliance(self):
        requirements = {
            'transaction_monitoring': True,
            'kyc_verification': True,
            'suspicious_activity_reports': True,
            'tax_reporting': True
        }
        
        return all(requirements.values())