암호화폐 거래소 개발에 관한 완전한 가이드

암호화폐 거래소란 무엇인가요?

암호화폐 거래소는 사용자가 비트코인, 이더리움, USDT 등과 같은 다양한 디지털 자산을 사고팔고 교환할 수 있는 온라인 플랫폼입니다. 거래소는 암호화폐 생태계에서 유동성 허브 역할을 하며, 자금이 암호화폐 시장에 진입하고 나가는 주요 경로입니다.

교환의 핵심 기능

글로벌 주요 거래소의 데이터 참고

교환 분류

CEX와 DEX 기술 비교

시스템 아키텍처 설계

프로덕션 등급 암호화폐 거래소의 기술 아키텍처는 수십 개의 마이크로서비스 모듈로 구성되어 있으며, 다음은 핵심 시스템의 계층적 구조입니다:

핵심 성과 지표

• 매칭 딜레이:< 100마이크로초 (단일 거래 쌍), 초당 100만 주문+ 지원
• API 응답:P 99 < 10ms 10ms, 100,000+ 동시 연결 지원
• 시장 밀어: 전체 틱 데이터 지연 < 5ms, WebSocket 방송
• 시스템 이용 가능성: 99.99% (연중 < 52분 휴식 시간)
• 데이터 일관성: 자금 오류 0, 조정 빈도 1분 ≤

매칭 엔진

매칭 엔진은 거래의 핵심으로, 가격 우선과 시간 우선 원칙에 따라 매수와 매도 주문을 매칭하는 역할을 합니다. 그 성과는 거래소의 경쟁력을 직접적으로 결정합니다.

매칭 알고리즘 코어 구현

// matching/engine.go - 撮合引擎核心
type MatchingEngine struct {
    Symbol    string
    OrderBook *OrderBook
    Trades    chan *Trade
    mu        sync.Mutex
}

type OrderBook struct {
    Bids *RedBlackTree  // 买单（价格降序）
    Asks *RedBlackTree  // 卖单（价格升序）
}

type Order struct {
    ID        uint64
    Side      Side      // Buy / Sell
    Type      OrderType // Limit / Market / StopLimit
    Price     Decimal   // 限价
    Quantity  Decimal   // 数量
    Filled    Decimal   // 已成交
    Timestamp int64     // 纳秒时间戳
    UserID    uint64
}

func (e *MatchingEngine) ProcessOrder(order *Order) []*Trade {
    e.mu.Lock()
    defer e.mu.Unlock()

    var trades []*Trade

    if order.Side == Buy {
        // 买单 vs 卖单簿匹配
        trades = e.matchBuyOrder(order)
    } else {
        // 卖单 vs 买单簿匹配
        trades = e.matchSellOrder(order)
    }

    // 未完全成交的限价单挂入订单簿
    if order.Remaining() > 0 && order.Type == Limit {
        e.OrderBook.Insert(order)
    }

    return trades
}

func (e *MatchingEngine) matchBuyOrder(buyOrder *Order) []*Trade {
    var trades []*Trade
    asks := e.OrderBook.Asks

    for asks.Len() > 0 && buyOrder.Remaining() > 0 {
        bestAsk := asks.Min().(*Order)

        // 价格不匹配则停止
        if buyOrder.Type == Limit && buyOrder.Price.LessThan(bestAsk.Price) {
            break
        }

        // 计算成交量
        matchQty := Decimal.Min(buyOrder.Remaining(), bestAsk.Remaining())
        matchPrice := bestAsk.Price // 按挂单价成交

        // 生成成交记录
        trade := &Trade{
            Price:    matchPrice,
            Quantity: matchQty,
            BuyerID:  buyOrder.UserID,
            SellerID: bestAsk.UserID,
            BuyOrderID:  buyOrder.ID,
            SellOrderID: bestAsk.ID,
            Timestamp: time.Now().UnixNano(),
        }
        trades = append(trades, trade)

        // 更新订单状态
        buyOrder.Filled = buyOrder.Filled.Add(matchQty)
        bestAsk.Filled = bestAsk.Filled.Add(matchQty)

        // 完全成交则移除
        if bestAsk.Remaining().IsZero() {
            asks.DeleteMin()
        }
    }
    return trades
}

엔진 설계 포인트 일치

• 기억이 우선입니다: 주문 장부는 모두 메모리에 유지되며, 빨간색과 검은색 트리/스킵 테이블을 사용해 O(log N) 삽입 및 삭제를 보장합니다
• 단일 나사산 매칭: 각 거래 쌍은 독립적으로 스레드되어 락 경쟁을 방지하고 확실성을 보장합니다
• 이벤트 추적성: 모든 주문 연산은 결함 복구를 지원하기 위해 WAL에 기록됩니다
• 스냅샷 메커니즘: 주문서장 스냅샷을 정기적으로 유지하며, 빠른 재시작을 위해 WAL과 결합하세요
• 연속화: 각 명령은 재생의 일관성을 보장하기 위해 전역 점진적 일련번호가 할당됩니다

주문 유형 vs. 주문 장부

지원되는 주문 유형

주문장 자료구조

// orderbook/book.go - 高性能订单簿
type PriceLevel struct {
    Price    Decimal
    Orders   *list.List  // 同价格FIFO队列
    Quantity Decimal     // 该价位总挂单量
}

type OrderBook struct {
    bids     *skiplist.SkipList  // 买单（降序）
    asks     *skiplist.SkipList  // 卖单（升序）
    orderMap map[uint64]*Order   // O(1) 订单查找
}

// 获取深度数据（L2）
func (ob *OrderBook) GetDepth(levels int) *Depth {
    depth := &Depth{
        Bids: make([]PriceQty, 0, levels),
        Asks: make([]PriceQty, 0, levels),
    }

    iter := ob.bids.Iterator()
    for i := 0; i < levels && iter.Next(); i++ {
        level := iter.Value().(*PriceLevel)
        depth.Bids = append(depth.Bids, PriceQty{
            Price:    level.Price,
            Quantity: level.Quantity,
        })
    }

    iter = ob.asks.Iterator()
    for i := 0; i < levels && iter.Next(); i++ {
        level := iter.Value().(*PriceLevel)
        depth.Asks = append(depth.Asks, PriceQty{
            Price:    level.Price,
            Quantity: level.Quantity,
        })
    }
    return depth
}

지갑 시스템

지갑 시스템은 사용자 디지털 자산의 충전, 출금, 집계 및 안전한 저장을 관리하는 역할을 하며, 이는 교환 자금 보안의 핵심입니다.

지갑 아키텍처

재충전 감지 소스 코드

// wallet/deposit_scanner.go - 充值扫描服务
type DepositScanner struct {
    chain       string
    rpcClient   BlockchainClient
    db          *gorm.DB
    confirmations int
}

func (s *DepositScanner) ScanBlock(blockNum uint64) error {
    block, err := s.rpcClient.GetBlockByNumber(blockNum)
    if err != nil { return err }

    for _, tx := range block.Transactions {
        // 检查是否为用户充值地址
        if s.isUserDepositAddress(tx.To) {
            deposit := &Deposit{
                TxHash:      tx.Hash,
                Chain:       s.chain,
                Address:     tx.To,
                Amount:      tx.Value,
                BlockNumber: blockNum,
                Status:      "pending",
            }
            s.db.Create(deposit)
        }

        // ERC-20 Transfer 事件检测
        for _, log := range tx.Logs {
            if s.isERC20Transfer(log) {
                token, to, amount := s.decodeTransfer(log)
                if s.isUserDepositAddress(to) {
                    deposit := &Deposit{
                        TxHash:  tx.Hash,
                        Chain:   s.chain,
                        Token:   token,
                        Address: to,
                        Amount:  amount,
                        Status:  "pending",
                    }
                    s.db.Create(deposit)
                }
            }
        }
    }
    return nil
}

// 确认数达标后入账
func (s *DepositScanner) ConfirmDeposits(currentBlock uint64) {
    var pending []Deposit
    s.db.Where("status = ? AND chain = ?", "pending", s.chain).Find(&pending)

    for _, d := range pending {
        if currentBlock - d.BlockNumber >= uint64(s.confirmations) {
            // 入账到用户余额
            s.creditUserBalance(d.UserID, d.Token, d.Amount)
            d.Status = "confirmed"
            s.db.Save(&d)
        }
    }
}

선물 거래(영구 계약)

영구 선물은 암호화폐 거래소의 핵심 파생상품으로, 만기일이 없고 자금 조율 메커니즘을 통해 현물 가격에 고정되어 있습니다.

영구 계약의 핵심 메커니즘

청산 엔진

// liquidation/engine.go - 强平引擎
type LiquidationEngine struct {
    positions  *PositionStore
    markPrices *MarkPriceService
    insurance  *InsuranceFund
}

func (le *LiquidationEngine) CheckPositions() {
    positions := le.positions.GetAllOpen()

    for _, pos := range positions {
        markPrice := le.markPrices.Get(pos.Symbol)
        marginRatio := le.calcMarginRatio(pos, markPrice)

        if marginRatio <= pos.MaintenanceMarginRate {
            le.liquidate(pos, markPrice)
        }
    }
}

func (le *LiquidationEngine) calcMarginRatio(pos *Position, markPrice Decimal) Decimal {
    // 未实现盈亏
    unrealizedPnL := pos.Side.PnL(pos.EntryPrice, markPrice, pos.Size)
    // 账户权益
    equity := pos.Margin.Add(unrealizedPnL)
    // 仓位价值
    positionValue := markPrice.Mul(pos.Size)
    // 保证金率
    return equity.Div(positionValue)
}

func (le *LiquidationEngine) liquidate(pos *Position, markPrice Decimal) {
    // 1. 取消该仓位所有挂单
    le.cancelOpenOrders(pos)
    // 2. 以破产价格提交平仓单
    bankruptcyPrice := le.calcBankruptcyPrice(pos)
    order := &Order{
        Symbol:   pos.Symbol,
        Side:     pos.Side.Opposite(),
        Type:     Market,
        Quantity: pos.Size,
        Source:   "liquidation",
    }
    // 3. 盈余归入保险基金
    proceeds := le.executeClose(order, markPrice)
    if proceeds.GreaterThan(Zero) {
        le.insurance.Add(pos.Symbol, proceeds)
    }
}

위험 통제 시스템

위험 통제 시스템은 거래소의 보안 장벽 역할을 하여 비정상적인 행동을 실시간으로 모니터링하고 시장 조작과 자금 횡령을 방지합니다.

위험 통제 수준

실시간 위험 통제 규칙 엔진

// risk/realtime_engine.go
type RiskEngine struct {
    rules    []RiskRule
    metrics  *MetricsCollector
}

type RiskRule interface {
    Check(order *Order, context *RiskContext) *RiskResult
}

// 价格偏离检测
type PriceDeviationRule struct {
    MaxDeviation Decimal  // 如 5%
}

func (r *PriceDeviationRule) Check(order *Order, ctx *RiskContext) *RiskResult {
    if order.Type != Limit { return Pass() }
    
    lastPrice := ctx.LastTradePrice(order.Symbol)
    deviation := order.Price.Sub(lastPrice).Abs().Div(lastPrice)
    
    if deviation.GreaterThan(r.MaxDeviation) {
        return Reject("price_deviation_exceeded",
            fmt.Sprintf("偏离 %.2f%% 超过阈值 %.2f%%", deviation*100, r.MaxDeviation*100))
    }
    return Pass()
}

// 频率限制
type RateLimitRule struct {
    MaxOrdersPerSecond int
    window             map[uint64]*slidingWindow
}

func (r *RateLimitRule) Check(order *Order, ctx *RiskContext) *RiskResult {
    w := r.getWindow(order.UserID)
    if w.Count() >= r.MaxOrdersPerSecond {
        return Reject("rate_limit", "下单频率超限")
    }
    w.Add()
    return Pass()
}

유동성 관리

유동성은 교환의 생명줄입니다. 깊이가 잘 있는 주문 장부는 더 좁은 매수-매도 스프레드와 슬리피지를 제공하여 더 많은 트레이더가 긍정적인 사이클을 형성하도록 유도할 수 있습니다.

유동성의 원천

• 시장 조성자: 전문 기관들은 스프레드 이익을 얻기 위해 매수자와 매도자 양쪽 모두에게 계속 주문을 합니다. 수수료 할인이나 리베이트 인센티브가 보통 제공됩니다.
• API 트레이더: REST/WebSocket/FIX 프로토콜을 통해 접근하는 정량 팀은 많은 수의 하가 주문을 기여합니다.
• 벽돌을 옮겨 가면 안 돼: 차익거래 로봇은 서로 다른 거래소 간 유동성을 이동시켜 가격 수렴을 돕습니다.
• 유동성 집계: 깊이를 보충하기 위한 제3자 유동성 풀(예: B2C2, Cumberland) 접근.

마켓메이커 API 설계

// 批量下单接口（低延迟专用）
POST /api/v1/mm/batch-orders
{
    "symbol": "BTC-USDT",
    "orders": [
        {"side": "buy",  "price": "67450.00", "qty": "0.5", "type": "limit"},
        {"side": "buy",  "price": "67400.00", "qty": "1.0", "type": "limit"},
        {"side": "sell", "price": "67550.00", "qty": "0.5", "type": "limit"},
        {"side": "sell", "price": "67600.00", "qty": "1.0", "type": "limit"}
    ],
    "cancelPrevious": true  // 原子性替换旧订单
}

// 做市商专属 WebSocket（Colocation 级别）
// 延迟 < 1ms，独立通道，优先处理
ws://exchange.com/ws/mm?apiKey=xxx&dedicatedLine=true

KYC 및 준수 시스템

전 세계적으로 규제가 강화되면서, KYC(고객 확인)와 AML(자금세탁방지)이 거래소의 필수 요건이 되었습니다.

KYC 단계별 검증

AML 준수 시스템

• 트랜잭션 모니터링: 대규모 트랜잭션의 실시간 감지, 분할 트랜잭션(구조화), 빠른 인/아웃 모드
• 온체인 분석: 체인나리시스/엘립틱을 통합하여 고위험 주소(다크웹, 코인 믹서, 제재 목록) 식별
• 수색 구조 보고서: 의심스러운 활동은 자동으로 보고서를 생성하여 각 관할구역의 금융 정보 부서에 제출합니다
• 여행 규칙: FATF 여행 규칙을 준수하세요. 대규모 송금은 송금인/수신인 신원 정보를 포함합니다

보안 시스템

다층 보안 보호

추천 기술 스택

거래소 개발 과정

NovaLinkR 팀의 여러 교환 프로젝트 납품 경험을 바탕으로 전체 개발 과정은 다음과 같습니다: