清结算与对账体系

成交（Trade）
  │
  ├─► 清算（Clearing）：计算应收应付、净额、保证金
  │
  ├─► 交收（Settlement）：资金与证券的实际划转
  │
  └─► 存管（Custody）：证券登记与托管

class CashAccount:
    def __init__(self):
        self.total = 0.0          # 总资金
        self.withdrawable = 0.0   # 可取资金
        self.frozen = 0.0         # 冻结（挂单占用）

    def sell_stock(self, amount):
        self.total += amount      # 卖出所得立即可用，但不可取

    def settle_end_of_day(self):
        self.withdrawable = self.total - self.frozen   # 日终：可用转为可取

当日盈亏 = (当日结算价 − 昨日结算价) × 持仓量 × 合约乘数 × 方向
新保证金 = 当日结算价 × 持仓量 × 合约乘数 × 保证金率

def mark_to_market(position, prev_settle, cur_settle, multiplier=300):  # 乘数 300 元/点
    direction = 1 if position.side == 'LONG' else -1
    pnl = (cur_settle - prev_settle) * position.qty * multiplier * direction
    new_margin = cur_settle * position.qty * multiplier * position.margin_rate
    return pnl, new_margin

def check_margin_call(account):
    available = account.cash - account.margin_occupied
    if available < 0:   # 触发追保，需在规定时间内补足
        return {'action': 'margin_call', 'shortfall': -available}
    return None

class Position:
    def __init__(self, symbol):
        self.symbol = symbol
        self.long_qty = 0        # 多头持仓
        self.short_qty = 0       # 空头持仓
        self.yd_long = 0         # 昨多（可平）
        self.yd_short = 0        # 昨空（可平）
        self.frozen_long = 0     # 冻结的多头（挂卖单）
        self.frozen_short = 0    # 冻结的空头（挂买单）
        self.avg_cost = 0.0      # 持仓均价

    @property
    def available_long(self):
        return self.yd_long - self.frozen_long   # 可平多头 = 昨多 − 已冻结

    def on_fill(self, side, qty, price):
        if side == 'BUY':
            self.long_qty += qty
            total_cost = self.avg_cost * (self.long_qty - qty) + price * qty  # 重算均价
            self.avg_cost = total_cost / self.long_qty
        else:
            self.short_qty += qty

移动加权平均：每笔成交都重算均价（常用）
先进先出（FIFO）：按买入顺序配对（用于税务）

def reconcile_trades(my_trades, broker_trades):
    my_map = {t.trade_id: t for t in my_trades}
    broker_map = {t.trade_id: t for t in broker_trades}
    diffs = []
    for tid in set(my_map) | set(broker_map):
        mine, theirs = my_map.get(tid), broker_map.get(tid)
        if mine is None:
            diffs.append(('missing_local', tid, theirs))
        elif theirs is None:
            diffs.append(('missing_broker', tid, mine))
        elif not same_trade(mine, theirs):
            diffs.append(('field_mismatch', tid, mine, theirs))
    return diffs

1. 定位：差异出现在哪个环节（回报丢失 / 券商错误 / 计算错误）
2. 分类：是延迟差异（自愈）还是真实差异（需调账）
3. 处置：以权威数据源为准修正本地账
4. 记录：留痕，供审计

交易所 > 券商/期货公司 > 你的系统

def adjust_position(local_pos, broker_pos, reason):
    diff = broker_pos.qty - local_pos.qty
    if diff == 0:
        return None
    adjustment = {   # 生成调账记录，而不是直接改数
        'symbol': local_pos.symbol,
        'before': local_pos.qty,
        'after': broker_pos.qty,
        'diff': diff,
        'reason': reason,
        'ts': time.time(),
    }
    audit_log.append(adjustment)
    local_pos.qty = broker_pos.qty
    return adjustment

1. 幂等：同一份对账单重复导入不产生重复数据
2. 可重跑：对账任务失败后能重新执行
3. 可追溯：每个差异都有处理记录

-- 对账单表，用 (trade_date, trade_id) 作为唯一键
INSERT INTO broker_trades (trade_date, trade_id, symbol, qty, price)
VALUES (?, ?, ?, ?, ?)
ON CONFLICT (trade_date, trade_id) DO NOTHING;

16:00  券商发布对账单
16:30  导入对账单（幂等）
17:00  执行对账（流水 / 持仓 / 资金）
17:30  生成差异报告
18:00  差异处理（自动 + 人工）

def sync_orders_from_broker(broker_api, local_orders):  # 主动拉取，补齐丢失回报
    broker_orders = broker_api.query_orders()
    for bo in broker_orders:
        lo = local_orders.get(bo.order_id)
        if lo is None or lo.filled != bo.filled:
            apply_broker_state(lo, bo)   # 本地状态落后，以券商为准

def apply_fill(fill, processed_set):
    if fill.trade_id in processed_set:
        return False              # 已处理，幂等跳过
    processed_set.add(fill.trade_id)
    update_position(fill)
    update_cash(fill)
    return True

def daily_pnl(positions, prev_close, cur_close, trades):
    realized = sum(t.pnl for t in trades if t.is_closing)   # 已实现盈亏
    unrealized = sum(   # 浮动盈亏：持仓部分的市值变化
        (cur_close[p.symbol] - prev_close[p.symbol]) * p.qty * p.multiplier
        for p in positions
    )
    return {'realized': realized, 'unrealized': unrealized,
            'total': realized + unrealized}