交易基础概念

type LimitOrder struct {
    OrderID   string
    UserID    string
    Symbol    string  // "BTC/USDT"
    Side      string  // "buy" or "sell"
    Price     float64 // 限定价格
    Quantity  float64 // 数量
    Filled    float64 // 已成交数量
    Status    string  // "pending", "partial", "filled", "cancelled"
    CreatedAt time.Time
}

type MarketOrder struct {
    OrderID   string
    UserID    string
    Symbol    string
    Side      string
    Quantity  float64 // 要买/卖的数量
    Status    string
    CreatedAt time.Time
}

type StopOrder struct {
    OrderID     string
    UserID      string
    Symbol      string
    Side        string
    StopPrice   float64 // 触发价格
    LimitPrice  float64 // 限价（可选）
    Quantity    float64
    OrderType   string  // "stop_market" or "stop_limit"
    Triggered   bool    // 是否已触发
    Status      string
    CreatedAt   time.Time
}

type TradingPair struct {
    Symbol          string  // "BTC/USDT"
    BaseAsset       string  // "BTC"
    QuoteAsset      string  // "USDT"

    // 价格精度
    PricePrecision  int     // 小数位数
    PriceTickSize   float64 // 最小价格变动单位

    // 数量精度
    QuantityPrecision int
    MinQuantity      float64 // 最小下单量
    MaxQuantity      float64 // 最大下单量

    // 金额限制
    MinNotional      float64 // 最小成交额

    // 手续费
    MakerFee        float64 // Maker手续费率
    TakerFee        float64 // Taker手续费率

    // 状态
    Status          string  // "active", "suspended"
}

func determineMakerTaker(order *Order, matchedPrice float64) string {
    if order.Type == "market" {
        return "taker" // 市价单总是taker
    }

    if order.Side == "buy" {
        if order.Price >= matchedPrice {
            return "taker" // 买价高于或等于成交价，立即成交
        }
        return "maker"
    } else {
        if order.Price <= matchedPrice {
            return "taker" // 卖价低于或等于成交价，立即成交
        }
        return "maker"
    }
}

func calculateFee(tradingPair *TradingPair, amount float64, role string) float64 {
    var feeRate float64

    if role == "maker" {
        feeRate = tradingPair.MakerFee
    } else {
        feeRate = tradingPair.TakerFee
    }

    return amount * feeRate
}

// 示例
// 成交：0.1 BTC @ 50,000 USDT
// 成交额：5,000 USDT
// Taker手续费（0.2%）：5,000 * 0.002 = 10 USDT
// Maker手续费（0.1%）：5,000 * 0.001 = 5 USDT

type OrderBook struct {
    Symbol string
    Bids   *PriceLevel // 买盘
    Asks   *PriceLevel // 卖盘
    mu     sync.RWMutex
}

type PriceLevel struct {
    levels map[float64]*Level // 价格 -> 订单列表
}

type Level struct {
    Price    float64
    Quantity float64
    Orders   []*Order
}

type Trade struct {
    TradeID      string
    Symbol       string
    BuyOrderID   string
    SellOrderID  string
    BuyUserID    string
    SellUserID   string
    Price        float64
    Quantity     float64
    BuyerMaker   bool    // 买方是否为Maker
    Timestamp    time.Time
}

type Ticker struct {
    Symbol        string
    LastPrice     float64 // 最新成交价
    OpenPrice     float64 // 24h开盘价
    HighPrice     float64 // 24h最高价
    LowPrice      float64 // 24h最低价
    Volume        float64 // 24h成交量（基础货币）
    QuoteVolume   float64 // 24h成交额（计价货币）
    PriceChange   float64 // 24h价格变化
    PriceChangePercent float64 // 24h涨跌幅
    BidPrice      float64 // 当前最高买价
    AskPrice      float64 // 当前最低卖价
    Timestamp     time.Time
}

type Kline struct {
    Symbol    string
    Interval  string    // "1m", "5m", "1h", "1d"
    OpenTime  time.Time
    CloseTime time.Time
    Open      float64   // 开盘价
    High      float64   // 最高价
    Low       float64   // 最低价
    Close     float64   // 收盘价
    Volume    float64   // 成交量
    Trades    int       // 成交笔数
}

func generateKline(trades []*Trade, interval string) *Kline {
    if len(trades) == 0 {
        return nil
    }

    kline := &Kline{
        Symbol:   trades[0].Symbol,
        Interval: interval,
        Open:     trades[0].Price,
        High:     trades[0].Price,
        Low:      trades[0].Price,
        Close:    trades[len(trades)-1].Price,
        OpenTime: trades[0].Timestamp,
        CloseTime: trades[len(trades)-1].Timestamp,
        Volume:   0,
        Trades:   len(trades),
    }

    for _, trade := range trades {
        if trade.Price > kline.High {
            kline.High = trade.Price
        }
        if trade.Price < kline.Low {
            kline.Low = trade.Price
        }
        kline.Volume += trade.Quantity
    }

    return kline
}

type Balance struct {
    UserID    string
    Currency  string
    Available float64 // 可用余额
    Frozen    float64 // 冻结余额（挂单占用）
    Total     float64 // 总余额 = Available + Frozen
}

// 冻结余额
balance.Available -= orderAmount
balance.Frozen += orderAmount

// 买单成交
balance.Frozen -= quoteAmount        // 解冻计价货币
balance.Available += baseAmount      // 增加基础货币

// 卖单成交
balance.Frozen -= baseAmount         // 解冻基础货币
balance.Available += quoteAmount     // 增加计价货币

// 解冻余额
balance.Frozen -= orderAmount
balance.Available += orderAmount

func calculateSlippage(marketPrice, executionPrice float64) float64 {
    return (executionPrice - marketPrice) / marketPrice
}

func checkSlippage(order *MarketOrder, maxSlippage float64) error {
    marketPrice := getMarketPrice(order.Symbol, order.Side)
    estimatedPrice := estimateExecutionPrice(order)

    slippage := calculateSlippage(marketPrice, estimatedPrice)

    if slippage > maxSlippage {
        return fmt.Errorf("slippage %.2f%% exceeds maximum %.2f%%",
            slippage*100, maxSlippage*100)
    }

    return nil
}