中心化交易所现货与杠杆业务

public class MatchingEngine {
    
    // 订单簿：买盘的优先级队列（价格降序，同价格时间升序）
    private PriorityQueue<Order> bidBook = new PriorityQueue<>((a, b) -> {
        int priceCompare = b.getPrice().compareTo(a.getPrice());
        return priceCompare != 0 ? priceCompare : 
               Long.compare(a.getTimestamp(), b.getTimestamp());
    });
    
    // 订单簿：卖盘的优先级队列（价格升序，同价格时间升序）
    private PriorityQueue<Order> askBook = new PriorityQueue<>((a, b) -> {
        int priceCompare = a.getPrice().compareTo(b.getPrice());
        return priceCompare != 0 ? priceCompare : 
               Long.compare(a.getTimestamp(), b.getTimestamp());
    });
    
    // 撮合入口
    public List<Trade> match(Order newOrder) {
        List<Trade> trades = new ArrayList<>();
        
        if (newOrder.getSide() == Side.BUY) {
            // 买单与卖盘撮合
            trades = matchWithAsks(newOrder);
        } else {
            // 卖单与买盘撮合
            trades = matchWithBids(newOrder);
        }
        
        return trades;
    }
    
    private List<Trade> matchWithAsks(Order buyOrder) {
        List<Trade> trades = new ArrayList<>();
        
        while (!buyOrder.isFilled() && !askBook.isEmpty()) {
            Order bestAsk = askBook.peek();
            
            // 价格是否匹配（买价 >= 卖价）
            if (buyOrder.getPrice().compareTo(bestAsk.getPrice()) < 0) {
                break;  // 无法成交
            }
            
            // 撮合
            BigDecimal tradeQty = buyOrder.getRemainingQty()
                .min(bestAsk.getRemainingQty());
            BigDecimal tradePrice = bestAsk.getPrice();  // 以卖价成交
            
            Trade trade = new Trade(buyOrder, bestAsk, tradeQty, tradePrice);
            trades.add(trade);
            
            // 更新订单状态
            buyOrder.fill(tradeQty);
            bestAsk.fill(tradeQty);
            
            // 完全成交的订单从订单簿移除
            if (bestAsk.isFilled()) {
                askBook.poll();
            }
        }
        
        // 未完全成交的限价单进入订单簿
        if (!buyOrder.isFilled() && buyOrder.getType() == OrderType.LIMIT) {
            bidBook.offer(buyOrder);
        }
        
        return trades;
    }
}

// 假设价格精度为 0.01，价格范围 0-100000
// 使用数组索引直接定位，O(1) 复杂度
public class PriceLadder {
    
    private static final int PRICE_PRECISION = 2;  // 小数位
    private static final BigDecimal PRICE_TICK = new BigDecimal("0.01");
    private static final int MAX_PRICE_INDEX = 10_000_000;  // 支持到 100000.00
    
    // 每个价格档的订单链表
    private PriceLevel[] bidLevels = new PriceLevel[MAX_PRICE_INDEX];
    private PriceLevel[] askLevels = new PriceLevel[MAX_PRICE_INDEX];
    
    // 当前最优价索引
    private int bestBidIndex = 0;
    private int bestAskIndex = MAX_PRICE_INDEX - 1;
    
    // 价格 → 索引转换
    private int priceToIndex(BigDecimal price) {
        return price.movePointRight(PRICE_PRECISION).intValue();
    }
    
    // O(1) 插入订单
    public void addOrder(Order order) {
        int index = priceToIndex(order.getPrice());
        PriceLevel level = order.getSide() == Side.BUY ? 
                          bidLevels[index] : askLevels[index];
        if (level == null) {
            level = new PriceLevel(order.getPrice());
            if (order.getSide() == Side.BUY) {
                bidLevels[index] = level;
                bestBidIndex = Math.max(bestBidIndex, index);
            } else {
                askLevels[index] = level;
                bestAskIndex = Math.min(bestAskIndex, index);
            }
        }
        level.addOrder(order);
    }
    
    // O(1) 获取最优价
    public BigDecimal getBestBid() {
        return new BigDecimal(bestBidIndex).movePointLeft(PRICE_PRECISION);
    }
}

// 成交后的资产划转必须原子执行
@Transactional
public void settleTrade(Trade trade) {
    String buyerId = trade.getBuyerId();
    String sellerId = trade.getSellerId();
    String baseCurrency = trade.getBaseCurrency();   // BTC
    String quoteCurrency = trade.getQuoteCurrency(); // USDT
    BigDecimal qty = trade.getQuantity();
    BigDecimal price = trade.getPrice();
    BigDecimal amount = qty.multiply(price);
    
    // 买方：减少 USDT，增加 BTC
    walletService.deductAvailable(buyerId, quoteCurrency, amount);
    walletService.addAvailable(buyerId, baseCurrency, qty);
    
    // 卖方：减少 BTC，增加 USDT
    walletService.deductAvailable(sellerId, baseCurrency, qty);
    walletService.addAvailable(sellerId, quoteCurrency, amount);
    
    // 记录成交明细
    tradeHistoryService.save(trade);
}

// 全仓模式
public class CrossMarginCalculator {
    
    // 计算账户权益（总资产 - 总负债）
    public BigDecimal calculateEquity(Account account) {
        BigDecimal totalAsset = account.getBalances().values().stream()
            .map(Balance::getTotal)  // 可用 + 冻结
            .reduce(BigDecimal.ZERO, BigDecimal::add);
        
        BigDecimal totalDebt = account.getDebts().values().stream()
            .map(Debt::getPrincipal)
            .reduce(BigDecimal.ZERO, BigDecimal::add);
        
        return totalAsset.subtract(totalDebt);
    }
    
    // 计算保证金率
    public BigDecimal calculateMarginRatio(Account account) {
        BigDecimal equity = calculateEquity(account);
        BigDecimal totalPositionValue = calculateTotalPositionValue(account);
        
        if (totalPositionValue.compareTo(BigDecimal.ZERO) == 0) {
            return BigDecimal.valueOf(Long.MAX_VALUE);  // 无仓位
        }
        
        return equity.divide(totalPositionValue, 4, RoundingMode.DOWN);
    }
    
    // 检查是否触发强平
    public boolean isLiquidationTriggered(Account account) {
        BigDecimal marginRatio = calculateMarginRatio(account);
        BigDecimal maintenanceMarginRate = account.getMaintenanceMarginRate();  // 如 0.05 (5%)
        
        return marginRatio.compareTo(maintenanceMarginRate) < 0;
    }
}

@Service
public class LiquidationService {
    
    @Autowired
    private RiskEngine riskEngine;
    
    @Autowired
    private MatchingEngine matchingEngine;
    
    // 定时扫描或事件驱动检查
    @Scheduled(fixedDelay = 100)  // 每100ms检查一次
    public void checkLiquidation() {
        List<Account> highRiskAccounts = riskEngine.getHighRiskAccounts();
        
        for (Account account : highRiskAccounts) {
            if (shouldLiquidate(account)) {
                executeLiquidation(account);
            }
        }
    }
    
    private void executeLiquidation(Account account) {
        try {
            // 1. 冻结账户，禁止新下单
            account.freeze();
            
            // 2. 取消所有未成交订单
            orderService.cancelAllOrders(account.getId());
            
            // 3. 市价平仓（以当前最优价立即卖出）
            List<Position> positions = account.getPositions();
            for (Position position : positions) {
                Order liquidationOrder = Order.builder()
                    .accountId(account.getId())
                    .symbol(position.getSymbol())
                    .side(position.getSide() == Side.BUY ? Side.SELL : Side.BUY)
                    .type(OrderType.MARKET)  // 市价单
                    .quantity(position.getQuantity())
                    .build();
                
                // 发送到撮合引擎
                matchingEngine.submitOrder(liquidationOrder);
            }
            
            // 4. 归还借款
            settleDebt(account);
            
            // 5. 剩余资金返还用户
            BigDecimal remaining = account.getEquity();
            if (remaining.compareTo(BigDecimal.ZERO) > 0) {
                walletService.transferToSpot(account.getId(), remaining);
            }
            
            // 6. 记录强平日志
            liquidationLogService.save(new LiquidationLog(account, remaining));
            
        } catch (Exception e) {
            // 强平失败，触发保险基金或自动减仓
            insuranceFundService.handleFailedLiquidation(account);
        }
    }
}

public class RiskLimitService {
    
    public void checkRiskLimit(String accountId, String symbol, 
                               BigDecimal newPosition) {
        RiskLimit limit = riskLimitRepository.findByAccountId(accountId);
        
        // 检查持仓限额
        if (newPosition.compareTo(limit.getPositionLimit()) > 0) {
            throw new RiskLimitExceededException(
                "持仓超过风险限额: " + limit.getPositionLimit());
        }
        
        // 检查杠杆倍数
        BigDecimal leverage = calculateLeverage(accountId);
        if (leverage.compareTo(limit.getMaxLeverage()) > 0) {
            throw new RiskLimitExceededException(
                "杠杆超过限制: " + limit.getMaxLeverage());
        }
    }
}

// 价格精度 0.01，范围 0-100000，共 1000 万个价格档
// 使用 int[] 索引，O(1) 定位

public class FastOrderBook {
    
    // 每个价格档是一个链表（同价格按时间排序）
    private Order[] bidLevels = new Order[10_000_000];
    private Order[] askLevels = new Order[10_000_000];
    
    // 当前最优价索引
    private int bestBid = 0;
    private int bestAsk = 9_999_999;
    
    // O(1) 插入
    public void addOrder(Order order) {
        int index = priceToIndex(order.getPrice());
        Order[] levels = order.isBuy() ? bidLevels : askLevels;
        
        // 头插法（时间最新在最前）
        order.next = levels[index];
        levels[index] = order;
        
        // 更新最优价
        if (order.isBuy() && index > bestBid) bestBid = index;
        if (!order.isBuy() && index < bestAsk) bestAsk = index;
    }
    
    // O(1) 获取最优价
    public BigDecimal getBestBid() {
        return indexToPrice(bestBid);
    }
}

public class FeeCalculator {
    
    public Fee calculateFee(Order order, User user) {
        // 基础费率
        BigDecimal baseRate = order.isMaker() ? 
            new BigDecimal("0.0002") : new BigDecimal("0.0004");
        
        // VIP 折扣
        BigDecimal vipDiscount = getVipDiscount(user.getVipLevel());
        
        // 平台币抵扣折扣
        BigDecimal tokenDiscount = user.isUseTokenFee() ? 
            new BigDecimal("0.25") : BigDecimal.ZERO;
        
        // 最终费率
        BigDecimal finalRate = baseRate
            .multiply(BigDecimal.ONE.subtract(vipDiscount))
            .multiply(BigDecimal.ONE.subtract(tokenDiscount));
        
        // 计算手续费
        BigDecimal fee = order.getAmount().multiply(finalRate);
        
        return new Fee(fee, finalRate);
    }
}