Разработка CEX-биржи: matching engine, безопасность, инфраструктура

Проектируем и разрабатываем блокчейн-решения полного цикла: от архитектуры смарт-контрактов до запуска DeFi-протоколов, NFT-маркетплейсов и криптобирж. Аудит безопасности, токеномика, интеграция с существующей инфраструктурой.
Показано 1 из 1Все 1305 услуг
Разработка CEX-биржи: matching engine, безопасность, инфраструктура
Сложный
от 2 недель до 3 месяцев
Часто задаваемые вопросы

Направления блокчейн-разработки

Этапы блокчейн-разработки

Последние работы

  • image_website-b2b-advance_0.webp
    Разработка сайта компании B2B ADVANCE
    1374
  • image_web-applications_feedme_466_0.webp
    Разработка веб-приложения для компании FEEDME
    1256
  • image_websites_belfingroup_462_0.webp
    Разработка веб-сайта для компании БЕЛФИНГРУПП
    965
  • image_ecommerce_furnoro_435_0.webp
    Разработка интернет магазина для компании FURNORO
    1208
  • image_logo-advance_0.webp
    Разработка логотипа компании B2B Advance
    667
  • image_crm_enviok_479_0.webp
    Разработка веб-приложения для компании Enviok
    954

Разработка централизованной криптобиржи (CEX) — один из самых сложных продуктов в криптоинфраструктуре. Matching engine, кастодиальная система, compliance-слой, market data и обеспечение ликвидности — всё это должно работать одновременно, надёжно и под нагрузкой. Типичные проблемы: latency матчинга более 100 мс, уязвимости в смарт-контрактах, низкая доступность. Мы проектируем и разрабатываем CEX под ключ, опираясь на 8-летний опыт в блокчейн-разработке и 5+ запущенных проектах. Ниже расскажу, что реально нужно для запуска серьёзной платформы.

Как мы проектируем архитектуру CEX?

Высокоуровневая схема

Client Layer
├── Web Trading Terminal (React/Vue)
├── Mobile Apps (iOS/Android)
└── API (REST + WebSocket + FIX)
        │
API Gateway / Load Balancer
        │
Service Layer
├── Auth Service (JWT + 2FA)
├── Order Service → OMS
├── Account Service → Balances
├── Market Data Service → Feeds
└── Notification Service
        │
Core Infrastructure
├── Matching Engine (C++/Rust/Go)
├── Risk Engine
├── Custody System
└── Settlement Engine
        │
Data Layer
├── PostgreSQL (accounts, orders, trades)
├── Redis (order book state, sessions)
├── Kafka (event streaming, audit log)
└── TimescaleDB (OHLCV, market data)

Принцип изоляции сервисов

Каждый сервис независим и общается через события (event-driven). Matching engine не знает про пользователей — он знает только про ордера. Account service не знает про торговлю — он знает про балансы. Это позволяет независимо масштабировать компоненты: matching engine на bare metal, остальное на Kubernetes. Сбой notification service не роняет торговлю. Деплой без downtime.

Почему matching engine так критичен?

Matching engine — единственный компонент, где производительность имеет экзистенциальное значение. Задержка >10 ms — это реальные потери для HFT-клиентов и market makers.

Tier Throughput Latency (order-to-ack) Технология
Start-up (<$1M/day) 1,000 ops/sec <50 ms Go / Java
Mid-tier ($1-50M/day) 10,000 ops/sec <5 ms Go / Rust
Large ($50M+/day) 100,000+ ops/sec <500 µs C++ / Rust

Order Book имплементация

use std::collections::BTreeMap;
use std::collections::VecDeque;

type Price = u64;  // Integer representation: price * 10^8
type Quantity = u64;

#[derive(Debug, Clone)]
struct Order {
    id: u64,
    price: Price,
    quantity: Quantity,
    remaining: Quantity,
    side: Side,
    order_type: OrderType,
    timestamp: u64,
    user_id: u64,
}

#[derive(Debug)]
struct PriceLevel {
    price: Price,
    total_quantity: Quantity,
    orders: VecDeque<u64>,  // order IDs в порядке времени
}

struct OrderBook {
    symbol: String,
    bids: BTreeMap<std::cmp::Reverse<Price>, PriceLevel>,
    asks: BTreeMap<Price, PriceLevel>,
    orders: std::collections::HashMap<u64, Order>,
}

impl OrderBook {
    fn match_order(&mut self, incoming: &mut Order) -> Vec<Trade> {
        let mut trades = Vec::new();
        let opposite_side = match incoming.side {
            Side::Buy => &mut self.asks,
            Side::Sell => &mut self.bids,
        };
        while incoming.remaining > 0 {
            let best_level = match incoming.side {
                Side::Buy => opposite_side.iter_mut().next(),
                Side::Sell => opposite_side.iter_mut().next(),
            };
            match best_level {
                None => break,
                Some((_, level)) => {
                    let price_matches = match incoming.side {
                        Side::Buy => incoming.price >= level.price,
                        Side::Sell => incoming.price <= level.price,
                    };
                    if !price_matches { break; }
                    while incoming.remaining > 0 && !level.orders.is_empty() {
                        let maker_id = *level.orders.front().unwrap();
                        let maker = self.orders.get_mut(&maker_id).unwrap();
                        let fill_qty = incoming.remaining.min(maker.remaining);
                        trades.push(Trade {
                            maker_order_id: maker_id,
                            taker_order_id: incoming.id,
                            price: level.price,
                            quantity: fill_qty,
                        });
                        incoming.remaining -= fill_qty;
                        maker.remaining -= fill_qty;
                        if maker.remaining == 0 {
                            level.orders.pop_front();
                            self.orders.remove(&maker_id);
                        }
                    }
                }
            }
        }
        trades
    }
}

Matching engine на Rust обрабатывает в 3 раза больше операций, чем аналогичный на Python. Мы используем Event Sourcing — все изменения состояния записываются как неизменяемая последовательность событий (OrderPlaced → OrderMatched → TradeFilled → OrderCancelled). Это даёт полный audit trail и возможность восстановления после краха, что признано лучшей практикой в высоконагруженных системах. Для mid-tier биржи экономия на инфраструктуре за счёт правильной архитектуры может быть значительной. Дополнительно, для проектов с объёмом торгов $1M/day мы снижаем затраты на KYC-интеграцию.

Как обеспечивается безопасность кастодиальной системы

Биржа хранит средства пользователей. Мы реализуем многоуровневую защиту:

  • Multi-sig cold storage: 95%+ средств в холодных кошельках с 3-of-5 multisig. Ключи физически разнесены по разным дата-центрам и странам. Используем HSM (Hardware Security Modules) для подписания.
  • Hot wallet: 2-5% средств для оперативных выводов с автоматическим пополнением из cold. Суточный лимит вывода превышает который требует ручного одобрения.
  • Withdrawal security: каждый вывод проверяется на whitelist адресов, velocity, AML-скрининг (Chainalysis, Elliptic). Сомнительные транзакции уходят на manual review.
Детали реализации кастодиальной защитыДля подписания транзакций используем HSM с ключами, разделёнными по принципу sharded secret. Каждая транзакция требует подтверждения от 3 из 5 ключей. Данные о балансах хранятся в отдельной базе с шифрованием на уровне строк.

KYC/AML и compliance

Таблица уровней верификации:

KYC Level Данные Дневной лимит
0 — Email Только email 0 (только просмотр)
1 — Basic Телефон + страна $500
2 — Standard ID + Selfie $10,000
3 — Enhanced Proof of address + source of funds $100,000
Institutional Корпоративные документы Unlimited

Интегрируем Sumsub или Onfido через REST API. Webhook при изменении статуса верификации. AML-скрининг каждого депозита и вывода в реальном времени.

Рыночные данные и интеграция TradingView

Real-time feeds

Matching Engine → Trade Events → Kafka
                                    │
                         ┌──────────┤
                         ▼          ▼
                 OHLCV Builder  Order Book Aggregator
                         │          │
                         └────┬─────┘
                              ▼
                     WebSocket Broadcaster
                     (horizontal scaling)
                              │
                    ┌─────────┼─────────┐
                    ▼         ▼         ▼
                Client 1   Client 2  Client N

WebSocket сервер публикует diff updates (дельта-изменения), что снижает трафик в 10-50 раз. Для профессионального trading terminal интегрируем TradingView Advanced Charts через UDF data feed и WebSocket.

Процесс работы над проектом

  1. Аналитика: исследование рынка, требования, выбор стека, экономика проекта.
  2. Проектирование: архитектура, прототип matching engine, спецификация API.
  3. Реализация: разработка всех модулей, написание смарт-контрактов (если нужны) на Solidity или Rust.
  4. Тестирование: unit, integration, load testing (до 50k ops/sec). Безопасность — аудит смарт-контрактов и pen test.
  5. Деплой: настройка инфраструктуры, мониторинг, запуск в продакшн. Обеспечение ликвидности через ботов или market makers.

Что входит в работу

  • Документация (архитектурная, API, deployment)
  • Исходный код с тестами
  • CI/CD pipeline
  • Доступы к инфраструктуре
  • Обучение команды
  • Поддержка 3 месяца после запуска

Сроки: от 12 до 24 месяцев в зависимости от функционала. Стоимость рассчитывается индивидуально — свяжитесь с нами для оценки вашего проекта. Мы подготовим детальную смету и roadmap. Типичный проект обходится заказчику в диапазоне, который мы обсуждаем индивидуально — но экономия на инфраструктуре за счёт правильной архитектуры может достигать 40% по сравнению с типовыми решениями. Мы разработали уже 5+ бирж и знаем все подводные камни. Получите консультацию по вашему проекту — оценим и предложим оптимальное решение.

Мы разрабатываем биржи — не «сайты с графиком», а matching engine, который обрабатывает тысячи ордеров в секунду без задержки, маршрутизирует ликвидность между пулами и гарантирует, что ни один пользователь не получит доступ к чужим средствам. Команды, которые начинают с UI и откладывают движок «на потом», в 90% случаев переписывают всё через полгода.

Какие проблемы решает правильная архитектура?

Order Book vs AMM: где ломается большинство проектов

Централизованные биржи (CEX) строятся вокруг order book + matching engine. Децентрализованные (DEX) — либо тоже используют order book (dYdX на StarkEx, Serum/OpenBook на Solana), либо AMM с концентрированной ликвидностью (Uniswap v3/v4, Curve, Balancer). Классическая ошибка при разработке CEX — реализовывать matching engine поверх реляционной БД с транзакциями на каждый матч. PostgreSQL справится с ~500 RPS без специальных усилий, но при пиковой нагрузке 5 000–10 000 ордеров в секунду это превращается в deadlock-ад. Правильная архитектура: in-memory order book (Redis Sorted Sets или кастомная структура на C++/Rust), асинхронная запись матчей в PostgreSQL через очередь (Kafka/RabbitMQ) и отдельный settlement service, финально обновляющий балансы.

Для DEX самая болезненная проблема — sandwich атаки и MEV. Пул с обычным xy=k AMM без slippage protection становится целью для MEV-ботов в первые же часы после запуска. Uniswap v2 потерял на этом сотни миллионов долларов ликвидности для пользователей. Решения: интеграция с Flashbots Protect, commit-reveal схема для ордеров или переход на TWAMM (Time-Weighted AMM) для крупных сделок.

Концентрированная ликвидность и impermanent loss

Uniswap v3 ввёл концентрированную ликвидность — LP выбирают ценовой диапазон, в котором предоставляют ликвидность. Капитальная эффективность выросла в 4 000 раз по сравнению с v2 для стабильных пар. Но реализовать этот механизм правильно — нетривиальная задача. Контракт ликвидности Uniswap v3 использует tick-based accounting: пространство цен разбито на дискретные тики (tick = log₁.0001(price)), каждый тик хранит накопленные fee growth и liquidity delta. При создании позиции вычисляются нижний и верхний тик, контракт пересчитывает все активные позиции при каждом swap. Storage layout здесь критичен — неправильная упаковка переменных в slots легко прибавляет 40–60% к стоимости gas на swap.

Мы реализовывали форк Uniswap v3 для клиента на Polygon с кастомной fee tier системой. Первоначальная версия тратила 180k gas на swap через 2 тика. После slot packing переменных в Tick.Info и инлайнинга нескольких internal вызовов — 112k gas. Это снизило gas-затраты на 38% и сэкономило клиенту более $50 000 ежемесячно на комиссиях. Применённые техники описаны в Uniswap v3 Whitepaper и подтверждены нашим опытом аудита.

Что такое matching engine и почему он критичен?

Production-ready matching engine строится по следующей схеме:

  • Order ingestion layer — WebSocket gateway (Go или Rust), принимает ордера, валидирует подпись, проверяет баланс через Redis, ставит в очередь. Latency на этом уровне должна быть <1ms.
  • Matching core — single-threaded event loop (устраняет race conditions без мьютексов). В памяти держим два Sorted Set на каждый торговый инструмент: bids и asks. FIFO matching для limit ордеров, immediate-or-cancel для маркет. Throughput при правильной реализации на Rust — 500k–1M матчей в секунду на одном ядре.
  • Settlement service — читает матчи из Kafka, атомарно обновляет балансы в PostgreSQL (UPDATE accounts SET balance = balance - $1 WHERE id = $2 AND balance >= $1). Optimistic locking через версионирование строк.
  • Withdrawal pipeline — отдельный сервис с cold/hot wallet архитектурой. Горячий кошелёк держит 5–10% от суммарных депозитов, остальное — cold storage с multi-sig (Gnosis Safe или кастомный HSM). Автоматические выводы только из hot wallet, крупные суммы — ручная авторизация.
Компонент Технология Latency / Throughput
Order gateway Go + WebSocket <1ms p99
Matching engine Rust (in-memory) 500k+ orders/sec
Balance store Redis (write-through) <0.5ms
Settlement DB PostgreSQL 14+ ~50k TPS с partitioning
Event streaming Apache Kafka 1M+ events/sec
Blockchain node Geth / Solana validator зависит от чейна

Как мы строим on-chain DEX: смарт-контракты и gas-оптимизация

Для DEX на EVM (Ethereum, Arbitrum, Optimism, Polygon) весь критический путь живёт в Solidity. Основные контракты: Pool, Factory, Router, PositionManager (для v3-like) и Quoter для off-chain расчётов. Типичные ошибки, которые мы видим в аудитах:

Reentrancy через callback. Uniswap v3 использует flash swap с callback (uniswapV3SwapCallback). Если в вашем роутере нет nonReentrant guard и вы не проверяете msg.sender == pool, контракт дренируется через вложенный вызов. Это не гипотетика — несколько форков v3 теряли средства именно так.

Oracle manipulation в AMM. Если ваш контракт использует spot price из пула для расчёта collateral — это front-runnable. Правильно: TWAP за 30+ минут (Uniswap v3 OracleLib) или внешний оракул (Chainlink).

Unbounded loops в liquidity range. Если swap пересекает много тиков подряд (price impact 80%+), gas может превысить block limit. Нужен MAX_TICKS_CROSSED с partial fill и возвратом остатка.

Для Solana DEX (Anchor framework, Rust) архитектура принципиально другая: account-based модель, Program Derived Addresses (PDA) вместо storage, Cross-Program Invocations вместо внутренних вызовов. Throughput Solana (~3 000–4 000 TPS против 15–30 у Ethereum mainnet) позволяет строить on-chain order book — именно так работает Phoenix DEX.

Liquidity bootstrapping и интеграция с агрегаторами

Запустить пул мало — нужно обеспечить ликвидность на старте. Практические механизмы:

  • Liquidity Bootstrapping Pool (LBP) — начальная цена высокая, весовые коэффициенты активов динамически смещаются, создавая давление продаж и равномерное распределение токена. Реализован в Balancer v2.
  • Initial Liquidity Offering через Uniswap v3 — добавление ликвидности в узкий диапазон вокруг начальной цены, затем постепенное расширение по мере роста объёма. Требует active liquidity management или интеграции с Arrakis/Gamma.
  • Интеграция с 1inch, Paraswap, Li.Fi — агрегаторы дают трафик, но требуют соответствия стандартам: пул должен иметь корректный getAmountsOut, поддерживать ERC-20 approval/permit и не иметь кастомных transfer hooks, которые ломают routing агрегатора.

Процесс разработки

Аналитика и проектирование начинаются с выбора архитектурной модели: CEX с кастодиальным хранением, non-custodial DEX или гибрид (off-chain order book + on-chain settlement, как dYdX v3). Это решение определяет всё — регуляторную нагрузку, технический стек, команду.

Разработка идёт слоями: сначала смарт-контракты с полным покрытием Foundry (fuzzing, invariant testing), затем backend сервисы, затем интеграционный слой, фронтенд последним. Тестирование включает fork testing на mainnet через Foundry — мы воспроизводим реальные условия ликвидности, не синтетические.

Аудит обязателен перед деплоем на mainnet. Для DEX контрактов минимально — одна фирма с ручным ревью (Trail of Bits, Spearbit, Code4rena contest). Для CEX custody — аудит процессов хранения ключей. Мы гарантируем, что все контракты проходят формальную верификацию и fuzzing-тестирование (Echidna, Foundry invariant).

Что входит в работу (deliverables)

По завершении проекта вы получаете:

  • Исходный код смарт-контрактов и backend-сервисов под вашу лицензию
  • Полную техническую документацию (архитектурные схемы, API-спецификации, инструкции по деплою)
  • Доступы к репозиторию и CI/CD pipeline
  • Обучение вашей команды работе с кодом (2–3 сессии)
  • Гарантию на найденные в процессе эксплуатации баги до 6 месяцев
  • Сертификат прохождения стороннего аудита безопасности

Ориентиры по срокам

  • DEX (AMM, xy=k) — от 3 до 5 месяцев: контракты + backend + UI
  • DEX с концентрированной ликвидностью (v3-like) — от 6 до 10 месяцев
  • CEX (matching engine + custody + торговый UI) — от 8 до 14 месяцев
  • Интеграция с существующим протоколом — от 4 до 8 недель

Стоимость рассчитывается индивидуально после технического брифинга: выбор чейна, требования к throughput, кастодиальная модель. Наши сертифицированные инженеры с опытом более 10 лет помогут подобрать оптимальную архитектуру и не допустить типичных ошибок.

Типичные грабли при запуске

  • Забывают про price oracle в AMM. Spot price манипулируется flash loan’ом за одну транзакцию. Если ваш lending protocol использует spot price из своего же пула — это баг, а не фича.
  • Горячий кошелёк без лимитов. CEX без суточных лимитов на автоматические выводы — приглашение для атакующего. Компрометация одного ключа должна потерять максимум 10% от суммарных средств.
  • Отсутствие circuit breaker. Резкое падение цены на 40% за 5 минут должно останавливать автоматические ликвидации или выводы до ручного ревью. Без этого cascading liquidation spiral уничтожает весь TVL.
  • Неправильный decimal handling. USDC использует 6 decimals, WBTC — 8, большинство токенов — 18. Смешивание без нормализации даёт либо потерю точности, либо overflow. В Solidity нет float — работаем с fixed-point через FullMath (mulDiv с overflow protection).

Хотите избежать этих проблем? Свяжитесь с нами для консультации — мы подберём архитектуру под ваш проект и назовём точные сроки. Закажите разработку биржи с гарантией качества и последующей поддержкой.