Разработка торгового бота для криптобиржи

Разработка торгового бота для криптобиржи

Бот для собственной биржи — это не то же самое, что бот для Binance. Здесь есть прямой доступ к внутреннему API, возможность market making без latency сети, контроль над комиссиями. Это и инструмент обеспечения ликвидности, и инструмент монетизации биржи.

Зачем бирже собственные боты

Молодая биржа без ликвидности — мёртвая биржа. Трейдеры приходят туда, где есть тонкий спред и глубокий стакан. Решение: внутренний market-making бот который:

• Поддерживает тонкий спред (0.05–0.1% для стабильных пар)
• Держит глубину стакана (достаточный объём на каждом уровне)
• Следит за ценой относительно внешних бирж (Binance, OKX)

Это легитимная практика — большинство бирж на старте используют внутренних маркет-мейкеров.

Архитектура маркет-мейкер бота

Стратегия цитирования

class MarketMakerBot:
    def __init__(self, pair: str, config: MMConfig):
        self.pair = pair
        self.spread_pct = config.spread_pct       # 0.1% = 0.001
        self.order_levels = config.order_levels   # количество уровней (5-10)
        self.level_spacing = config.level_spacing # расстояние между уровнями
        self.level_size = config.level_size       # объём на уровне
        self.reference_exchange = config.reference # Binance для price feed
    
    async def update_quotes(self):
        # Получаем reference price с внешней биржи
        ref_price = await self.get_reference_price()
        
        # Вычисляем bid/ask
        half_spread = ref_price * self.spread_pct / 2
        best_bid = ref_price - half_spread
        best_ask = ref_price + half_spread
        
        # Генерируем несколько уровней
        new_bids = []
        new_asks = []
        for i in range(self.order_levels):
            bid_price = best_bid * (1 - self.level_spacing * i)
            ask_price = best_ask * (1 + self.level_spacing * i)
            size = self.level_size * (1 + i * 0.5)  # увеличиваем размер дальше от mid
            
            new_bids.append({'price': bid_price, 'size': size})
            new_asks.append({'price': ask_price, 'size': size})
        
        await self.refresh_orders(new_bids, new_asks)
    
    async def refresh_orders(self, new_bids, new_asks):
        # Отменяем старые ордера и выставляем новые атомарно
        # Используем bulk cancel + bulk place для минимизации времени без котировок
        await self.exchange.cancel_all_orders(self.pair)
        await asyncio.gather(
            *[self.exchange.place_order(self.pair, 'buy', b['price'], b['size']) 
              for b in new_bids],
            *[self.exchange.place_order(self.pair, 'sell', a['price'], a['size']) 
              for a in new_asks]
        )

Управление инвентарём

При активной торговле инвентарь (соотношение base/quote) смещается. Нужна ребалансировка:

def calculate_inventory_skew(self, base_balance: float, quote_balance: float, 
                               mid_price: float) -> float:
    """
    Возвращает skew (-1.0 до +1.0)
    -1.0: весь баланс в base (слишком много куплено) -> снижаем bid, повышаем ask
    +1.0: весь баланс в quote (слишком много продано) -> повышаем bid, снижаем ask
    """
    base_value = base_balance * mid_price
    total_value = base_value + quote_balance
    
    if total_value == 0:
        return 0.0
    
    ideal_pct = 0.5  # целевой баланс 50/50
    current_pct = base_value / total_value
    return (ideal_pct - current_pct) * 2  # нормируем к [-1, 1]

def apply_inventory_skew(self, mid_price: float, skew: float) -> tuple:
    """Смещаем котировки в сторону снижения дисбаланса"""
    skew_adjustment = mid_price * self.skew_factor * skew
    adjusted_mid = mid_price + skew_adjustment
    
    bid = adjusted_mid * (1 - self.spread_pct / 2)
    ask = adjusted_mid * (1 + self.spread_pct / 2)
    return bid, ask

Защита от рыночных движений

Резкое движение рынка при открытых позициях — риск убытка. Защита:

async def check_price_deviation(self):
    """Останавливаем котирование при резком движении рынка"""
    current_ref = await self.get_reference_price()
    price_change = abs(current_ref - self.last_ref_price) / self.last_ref_price
    
    if price_change > self.max_price_change:  # например 0.5%
        await self.cancel_all_orders()
        await asyncio.sleep(self.pause_duration)  # пауза N секунд
        self.last_ref_price = current_ref

Внутренний доступ к бирже

Ключевое преимущество internal бота — он может работать через внутренний API биржи, минуя:

• HTTP overhead (внутренний вызов через IPC или gRPC)
• Rate limits (внутренние боты исключены из rate limiting)
• Комиссии (market-making бот может иметь нулевые или отрицательные комиссии)

// Прямой вызов matching engine без HTTP
type InternalBotConnector struct {
    matchingEngine *MatchingEngine
    balanceManager *BalanceManager
}

func (c *InternalBotConnector) PlaceOrder(order Order) ([]Trade, error) {
    // Прямой вызов, без сети
    return c.matchingEngine.AddOrder(order)
}

func (c *InternalBotConnector) GetOrderBook(pair string) OrderBook {
    return c.matchingEngine.GetSnapshot(pair)
}

Это снижает latency с 1–5 мс (HTTP) до < 100 мкс.

Мониторинг и P&L

class BotMetrics:
    def __init__(self):
        self.filled_volume = defaultdict(float)
        self.pnl = defaultdict(float)
        self.spread_captured = defaultdict(float)
    
    def on_fill(self, trade: Trade):
        pair = trade.pair
        self.filled_volume[pair] += trade.quantity
        
        # P&L расчёт: каждый fill с положительным спредом = доход
        if trade.is_maker:
            # Maker fill: мы получили спред
            spread_earned = abs(trade.price - self.mid_price[pair]) * trade.quantity
            self.spread_captured[pair] += spread_earned
    
    def get_stats(self) -> dict:
        return {pair: {
            'volume_24h': self.filled_volume[pair],
            'spread_captured': self.spread_captured[pair],
            'effective_spread_bps': self.spread_captured[pair] / self.filled_volume[pair] * 10000
                if self.filled_volume[pair] > 0 else 0
        } for pair in self.filled_volume}

Разработка торгового бота с market-making стратегией для внутреннего использования: 3–5 недель. Включает стратегию цитирования, инвентарный менеджмент, monitoring dashboard и интеграцию с внутренним API биржи.