powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/order_execution/domain/execution_batch.py

@@ -0,0 +1,108 @@
+"""One market slice's validated execution result."""
+
+from dataclasses import dataclass
+from datetime import datetime
+
+from quant_core.app.order_execution.constants import ExecutionAttemptOutcome
+from quant_core.app.order_execution.domain.order_event import (
+    ExecutionAttempt,
+    Fill,
+    OrderTransition,
+)
+
+
+def _check_tz_aware(value: datetime, field: str) -> datetime:
+    if value.tzinfo is None:
+        raise ValueError(f"{field} 必须 timezone-aware（Canonical 市场时间带时区）")
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class MarketSliceProcessingResult:
+    """一个时间片的订单撮合批次结果（结构化，不混用通用 error 字符串）
+
+    process_market_slice 只产生撮合结果；不修改 Portfolio——
+    调用方必须显式把 Fill 传给 IPortfolioUpdate.apply_fill。
+    """
+
+    slice_time: datetime
+    fills: tuple[Fill, ...] = ()
+    execution_attempts: tuple[ExecutionAttempt, ...] = ()
+    order_updates: tuple[OrderTransition, ...] = ()
+
+    def __post_init__(self) -> None:
+        _check_tz_aware(self.slice_time, "slice_time")
+        self._check_result_time_consistency()
+        self._check_batch_reference_consistency()
+
+    def _check_result_time_consistency(self) -> None:
+        """「本时间片撮合结果」：内部事件时间必须精确等于 slice_time"""
+        for fill in self.fills:
+            if fill.fill_time != self.slice_time:
+                raise ValueError(
+                    f"Fill.fill_time {fill.fill_time} 必须等于 slice_time {self.slice_time}"
+                )
+        for attempt in self.execution_attempts:
+            if attempt.event_time != self.slice_time:
+                raise ValueError(
+                    f"ExecutionAttempt.event_time {attempt.event_time} 必须等于 "
+                    f"slice_time {self.slice_time}"
+                )
+        for update in self.order_updates:
+            if update.event_time != self.slice_time:
+                raise ValueError(
+                    f"OrderUpdate.event_time {update.event_time} 必须等于 "
+                    f"slice_time {self.slice_time}"
+                )
+
+    def _check_batch_reference_consistency(self) -> None:
+        """批次一致性：技术 ID 唯一，FILLED attempt 与 Fill 一一对应"""
+        fill_ids = [f.fill_id for f in self.fills]
+        if len(fill_ids) != len(set(fill_ids)):
+            raise ValueError("fills 内 fill_id 不允许重复")
+        attempt_ids = [a.attempt_id for a in self.execution_attempts]
+        if len(attempt_ids) != len(set(attempt_ids)):
+            raise ValueError("execution_attempts 内 attempt_id 不允许重复")
+
+        fills_by_id = {f.fill_id: f for f in self.fills}
+        filled_attempt_fill_ids: list[str] = []
+        for attempt in self.execution_attempts:
+            if attempt.outcome is ExecutionAttemptOutcome.FILLED:
+                if attempt.fill_id is None:
+                    raise ValueError("FILLED attempt 必须携带 fill_id")
+                if attempt.fill_id not in fills_by_id:
+                    raise ValueError(
+                        f"FILLED attempt 引用的 fill_id {attempt.fill_id} 不存在于本批 fills"
+                    )
+                if fills_by_id[attempt.fill_id].order_id != attempt.order_id:
+                    raise ValueError(
+                        f"attempt.order_id {attempt.order_id} 与被引用 Fill.order_id "
+                        f"{fills_by_id[attempt.fill_id].order_id} 不一致"
+                    )
+                filled_attempt_fill_ids.append(attempt.fill_id)
+            # DEFERRED attempt 不携带 fill_id（由 ExecutionAttempt 自身校验保证）
+        if len(filled_attempt_fill_ids) != len(set(filled_attempt_fill_ids)):
+            raise ValueError("每个 Fill 只允许被一个 FILLED attempt 引用")
+        # 双向一一对应：比较集合本身，不依赖列表长度巧合
+        orphan = set(fill_ids) - set(filled_attempt_fill_ids)
+        if orphan:
+            raise ValueError(
+                f"每个 Fill 必须恰好被一个 FILLED attempt 引用，"
+                f"以下 fill_id 缺少解释来源：{sorted(orphan)}"
+            )
+
+        update_order_ids = [u.order_id for u in self.order_updates]
+        if any(not oid for oid in update_order_ids):
+            raise ValueError("order_updates 内 order_id 不允许为空")
+        latest_by_order: dict[str, OrderTransition] = {}
+        for update in self.order_updates:
+            previous = latest_by_order.get(update.order_id)
+            if previous is not None and (
+                previous.current_status is not update.previous_status
+                or previous.cumulative_filled_quantity != update.previous_cumulative_filled_quantity
+            ):
+                raise ValueError(
+                    f"同片订单迁移链不连续：{update.order_id} "
+                    f"{previous.current_status} → {update.previous_status}"
+                )
+            latest_by_order[update.order_id] = update

quant_core/app/order_execution/domain/order_entity.py

@@ -0,0 +1,197 @@
+"""订单聚合与状态迁移。
+
+本模块只依赖 Python 标准库和领域枚举，不依赖 Pydantic、入口协议或持久化框架。
+"""
+
+from datetime import datetime
+from decimal import Decimal
+
+from quant_core.app.order_execution.constants import (
+    OrderStatus,
+    OrderUpdateReason,
+)
+from quant_core.app.order_execution.domain.order_event import OrderTransition
+from quant_core.app.order_execution.domain.order_value import OrderIntent, OrderSnapshot
+
+ORDER_TRANSITIONS = {
+    OrderStatus.PENDING: frozenset(
+        {
+            OrderStatus.PARTIALLY_FILLED,
+            OrderStatus.FILLED,
+            OrderStatus.CANCELLED,
+            OrderStatus.EXPIRED,
+        }
+    ),
+    OrderStatus.PARTIALLY_FILLED: frozenset(
+        {
+            OrderStatus.PARTIALLY_FILLED,
+            OrderStatus.FILLED,
+            OrderStatus.CANCELLED,
+            OrderStatus.EXPIRED,
+        }
+    ),
+    OrderStatus.FILLED: frozenset(),
+    OrderStatus.CANCELLED: frozenset(),
+    OrderStatus.EXPIRED: frozenset(),
+}
+
+TERMINAL_ORDER_STATUSES = frozenset(
+    {OrderStatus.FILLED, OrderStatus.CANCELLED, OrderStatus.EXPIRED}
+)
+
+
+def is_terminal_order_status(status: OrderStatus) -> bool:
+    return status in TERMINAL_ORDER_STATUSES
+
+
+_REASONS = {
+    OrderStatus.PARTIALLY_FILLED: frozenset({OrderUpdateReason.PARTIALLY_FILLED}),
+    OrderStatus.FILLED: frozenset({OrderUpdateReason.FILLED}),
+    OrderStatus.EXPIRED: frozenset(
+        {
+            OrderUpdateReason.EXPIRED_AT_SESSION_CLOSE,
+            OrderUpdateReason.EXPIRED_AT_COARSE_SESSION_END,
+            OrderUpdateReason.EXPIRED_AT_BACKTEST_END,
+        }
+    ),
+    OrderStatus.CANCELLED: frozenset(
+        {
+            OrderUpdateReason.CANCELLED,
+            OrderUpdateReason.INSUFFICIENT_CASH_AT_EXECUTION,
+            OrderUpdateReason.INSUFFICIENT_AVAILABLE_POSITION_AT_EXECUTION,
+        }
+    ),
+}
+
+
+def validate_order_transition(previous: OrderStatus, current: OrderStatus) -> None:
+    if previous is current and current is not OrderStatus.PARTIALLY_FILLED:
+        raise ValueError(
+            f"订单状态无变化不允许产生迁移：{previous} → {current}（无变化的 OrderUpdate 属于伪造）"
+        )
+    if current not in ORDER_TRANSITIONS[previous]:
+        raise ValueError(f"非法订单状态迁移：{previous} → {current}")
+
+
+def validate_transition(update: OrderTransition) -> None:
+    validate_order_transition(update.previous_status, update.current_status)
+    previous = update.previous_cumulative_filled_quantity
+    current = update.cumulative_filled_quantity
+    quantity = update.order_quantity
+    if update.event_time.tzinfo is None:
+        raise ValueError("event_time 必须 timezone-aware（Canonical 市场时间带时区）")
+    if update.previous_status is OrderStatus.PENDING and previous != 0:
+        raise ValueError(f"PENDING 前态累计成交必须为 0，实际 {previous}")
+    if update.previous_status is OrderStatus.PARTIALLY_FILLED and not 0 < previous < quantity:
+        raise ValueError(
+            "PARTIALLY_FILLED 前态累计成交必须满足 0 < 前态累计 < 订单数量，"
+            f"实际 {previous}/{quantity}"
+        )
+    if previous > current:
+        raise ValueError(f"累计成交数量不允许倒退：{previous} → {current}")
+    if current > quantity:
+        raise ValueError(f"累计成交 {current} 超过订单数量 {quantity}")
+    if update.current_status is OrderStatus.PARTIALLY_FILLED:
+        if update.previous_status is OrderStatus.PENDING and not 0 < current < quantity:
+            raise ValueError(
+                "PENDING → PARTIALLY_FILLED 要求 0 < 累计成交 < 订单数量，"
+                f"实际 {current}/{quantity}"
+            )
+        if update.previous_status is OrderStatus.PARTIALLY_FILLED and current == previous:
+            raise ValueError("PARTIALLY_FILLED 自环要求累计成交严格增加（数量不增长属伪造）")
+    if update.current_status is OrderStatus.FILLED and current != quantity:
+        raise ValueError(f"FILLED 要求累计成交等于订单数量 {quantity}，实际 {current}")
+    if (
+        update.current_status in (OrderStatus.CANCELLED, OrderStatus.EXPIRED)
+        and current != previous
+    ):
+        raise ValueError(
+            f"{update.current_status} 终态迁移不得伪造新的成交量：{previous} → {current}"
+        )
+    if current == 0 and update.average_fill_price is not None:
+        raise ValueError("累计成交为 0 时 average_fill_price 必须为 None")
+    if current > 0 and update.average_fill_price is None:
+        raise ValueError("累计成交 > 0 时必须携带正的 Decimal average_fill_price")
+    if update.average_fill_price is not None and update.average_fill_price <= 0:
+        raise ValueError("average_fill_price 必须为正 Decimal")
+    if update.average_fill_price is not None and not update.average_fill_price.is_finite():
+        raise ValueError("average_fill_price 必须是有限 Decimal")
+    if update.reason_code not in _REASONS[update.current_status]:
+        raise ValueError(
+            f"reason_code {update.reason_code} 与目标状态 {update.current_status} 不一致"
+        )
+
+
+class Order:
+    """订单生命周期聚合；迁移验证成功后才修改状态。"""
+
+    def __init__(
+        self,
+        order_id: str,
+        intent: OrderIntent,
+        created_event_time: datetime,
+        submission_sequence: int,
+    ) -> None:
+        if not order_id or order_id.strip() != order_id or any(ch.isspace() for ch in order_id):
+            raise ValueError("order_id 不允许为空或包含空白字符")
+        if created_event_time.tzinfo is None:
+            raise ValueError("created_event_time 必须 timezone-aware（Canonical 市场时间带时区）")
+        if created_event_time < intent.creation_event_time:
+            raise ValueError("created_event_time 不得早于 intent.creation_event_time")
+        if submission_sequence < 0:
+            raise ValueError("submission_sequence 必须 >= 0")
+        self.order_id = order_id
+        self.intent = intent
+        self.status = OrderStatus.PENDING
+        self.created_event_time = created_event_time
+        self.submission_sequence = submission_sequence
+        self.filled_quantity = 0
+        self.average_fill_price: Decimal | None = None
+
+    @property
+    def remaining_quantity(self) -> int:
+        return self.intent.quantity - self.filled_quantity
+
+    def transition(
+        self,
+        current_status: OrderStatus,
+        event_time: datetime,
+        reason_code: OrderUpdateReason,
+        cumulative_filled_quantity: int | None = None,
+        average_fill_price: Decimal | None = None,
+    ) -> OrderTransition:
+        if isinstance(average_fill_price, float):
+            raise ValueError(
+                "average_fill_price 必须使用 Decimal，禁止 float（避免二进制浮点误差）"
+            )
+        update = OrderTransition(
+            order_id=self.order_id,
+            order_quantity=self.intent.quantity,
+            previous_status=self.status,
+            current_status=current_status,
+            previous_cumulative_filled_quantity=self.filled_quantity,
+            cumulative_filled_quantity=self.filled_quantity
+            if cumulative_filled_quantity is None
+            else cumulative_filled_quantity,
+            average_fill_price=self.average_fill_price
+            if average_fill_price is None
+            else average_fill_price,
+            event_time=event_time,
+            reason_code=reason_code,
+        )
+        validate_transition(update)
+        self.status = current_status
+        self.filled_quantity = update.cumulative_filled_quantity
+        self.average_fill_price = update.average_fill_price
+        return update
+
+    def snapshot(self) -> OrderSnapshot:
+        return OrderSnapshot(
+            self.order_id,
+            self.intent,
+            self.status,
+            self.created_event_time,
+            self.submission_sequence,
+            self.filled_quantity,
+            self.average_fill_price,
+        )

quant_core/app/order_execution/domain/order_event.py

@@ -0,0 +1,87 @@
+"""订单执行领域已经发生的不可变事实。"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
+
+from quant_core.app.order_execution.constants import (
+    ExecutionAttemptOutcome,
+    ExecutionDeferReason,
+    OrderSide,
+    OrderStatus,
+    OrderUpdateReason,
+)
+from quant_core.app.order_execution.domain.order_value import FeeBreakdown
+
+
+@dataclass(frozen=True, slots=True)
+class OrderTransition:
+    order_id: str
+    order_quantity: int
+    previous_status: OrderStatus
+    current_status: OrderStatus
+    previous_cumulative_filled_quantity: int
+    cumulative_filled_quantity: int
+    event_time: datetime
+    reason_code: OrderUpdateReason
+    average_fill_price: Decimal | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Fill:
+    """Portfolio 因交易而变化的唯一不可变输入。"""
+
+    order_id: str
+    instrument_id: str
+    side: OrderSide
+    quantity: int
+    price: Decimal
+    fees: FeeBreakdown
+    fill_time: datetime
+    fill_id: str = field(default_factory=lambda: str(uuid4()))
+
+    def __post_init__(self) -> None:
+        if not self.fill_id or not self.order_id:
+            raise ValueError("fill_id 和 order_id 不允许为空")
+        if not isinstance(self.side, OrderSide):
+            raise ValueError("side 必须是 OrderSide")
+        if self.quantity <= 0:
+            raise ValueError("成交数量必须 > 0")
+        if isinstance(self.price, float) or not self.price.is_finite() or self.price <= 0:
+            raise ValueError("成交价必须是正的有限 Decimal")
+        if self.fill_time.tzinfo is None:
+            raise ValueError("fill_time 必须 timezone-aware")
+
+
+@dataclass(frozen=True, slots=True)
+class ExecutionAttempt:
+    """一次实际撮合检查的不可变事实。"""
+
+    order_id: str
+    event_time: datetime
+    outcome: ExecutionAttemptOutcome
+    defer_reason: ExecutionDeferReason | None = None
+    market_event_refs: tuple[str, ...] = ()
+    fill_id: str | None = None
+    attempt_id: str = field(default_factory=lambda: str(uuid4()))
+
+    def __post_init__(self) -> None:
+        if self.event_time.tzinfo is None:
+            raise ValueError("event_time 必须 timezone-aware")
+        normalized_refs = tuple(sorted(self.market_event_refs))
+        if len(normalized_refs) != len(set(normalized_refs)) or any(
+            not ref for ref in normalized_refs
+        ):
+            raise ValueError("market_event_refs 不允许空值或重复")
+        object.__setattr__(self, "market_event_refs", normalized_refs)
+        if self.outcome is ExecutionAttemptOutcome.DEFERRED:
+            if self.defer_reason is None:
+                raise ValueError("DEFERRED attempt 必须携带 defer_reason")
+            if self.fill_id is not None:
+                raise ValueError("DEFERRED attempt 不得携带 fill_id")
+        else:
+            if not self.fill_id:
+                raise ValueError("FILLED attempt 必须携带 fill_id")
+            if self.defer_reason is not None:
+                raise ValueError("FILLED attempt 不得携带 defer_reason")

quant_core/app/order_execution/domain/order_policy.py

@@ -0,0 +1,29 @@
+"""订单执行领域的可替换 Policy 契约。"""
+
+from decimal import Decimal
+from typing import Protocol, runtime_checkable
+
+from quant_core.app.data.schema.trading_state_schema import InstrumentMarketState
+from quant_core.app.order_execution.constants import OrderSide
+from quant_core.app.order_execution.domain.order_value import (
+    FeeBreakdown,
+    OrderSnapshot,
+    TradabilityDecision,
+)
+
+
+@runtime_checkable
+class FeeModelProtocol(Protocol):
+    def compute(self, side: OrderSide, quantity: int, fill_price: Decimal) -> FeeBreakdown: ...
+
+
+@runtime_checkable
+class SlippageModelProtocol(Protocol):
+    def apply(self, side: OrderSide, bar_open: Decimal) -> Decimal: ...
+
+
+@runtime_checkable
+class TradabilityPolicyProtocol(Protocol):
+    def decide(
+        self, order: OrderSnapshot, market_state: InstrumentMarketState
+    ) -> TradabilityDecision: ...

quant_core/app/order_execution/domain/order_value.py

@@ -0,0 +1,142 @@
+"""订单执行领域的不可变值对象。"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from decimal import Decimal
+from uuid import uuid4
+
+from quant_core.app.order_execution.constants import (
+    ExecutionDeferReason,
+    ExecutionPolicy,
+    OrderAckStatus,
+    OrderRejectReason,
+    OrderSide,
+    OrderStatus,
+    OrderType,
+    TimeInForce,
+)
+from quant_core.app.order_execution.constants import TradabilityDecision as TradabilityDecisionKind
+
+
+@dataclass(frozen=True, slots=True)
+class OrderIntent:
+    """已经完成仓位计算和下单前约束检查的不可变下单意图。"""
+
+    strategy_id: str
+    instrument_id: str
+    side: OrderSide
+    quantity: int
+    creation_event_time: datetime
+    intent_id: str = field(default_factory=lambda: str(uuid4()))
+    order_type: OrderType = OrderType.MARKET
+    limit_price: Decimal | None = None
+    execution_policy: ExecutionPolicy = ExecutionPolicy.NEXT_BAR_OPEN
+    time_in_force: TimeInForce = TimeInForce.DAY
+    signal_refs: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        _identifier(self.intent_id, "intent_id")
+        _identifier(self.strategy_id, "strategy_id")
+        if not isinstance(self.side, OrderSide):
+            raise ValueError("side 必须是 OrderSide")
+        parts = self.instrument_id.split(".")
+        if len(parts) != 3 or any(not part for part in parts):
+            raise ValueError("instrument_id 必须是 Canonical 标识（market.exchange.symbol）")
+        if self.quantity <= 0:
+            raise ValueError("quantity 必须 > 0")
+        if self.creation_event_time.tzinfo is None:
+            raise ValueError("creation_event_time 必须 timezone-aware")
+        if self.limit_price is not None and (
+            isinstance(self.limit_price, float)
+            or not self.limit_price.is_finite()
+            or self.limit_price <= 0
+        ):
+            raise ValueError("limit_price 必须是正的有限 Decimal")
+        if self.order_type is OrderType.LIMIT and self.limit_price is None:
+            raise ValueError("LIMIT OrderIntent 必须提供 limit_price")
+        if self.order_type is OrderType.MARKET and self.limit_price is not None:
+            raise ValueError("MARKET OrderIntent 不允许提供 limit_price")
+
+
+@dataclass(frozen=True, slots=True)
+class OrderAck:
+    """提交意图后的接受或拒绝事实。"""
+
+    intent_id: str
+    status: OrderAckStatus
+    event_time: datetime
+    order_id: str | None = None
+    rejection_reason: OrderRejectReason | None = None
+    ack_id: str = field(default_factory=lambda: str(uuid4()))
+
+    def __post_init__(self) -> None:
+        _identifier(self.ack_id, "ack_id")
+        _identifier(self.intent_id, "intent_id")
+        if self.event_time.tzinfo is None:
+            raise ValueError("event_time 必须 timezone-aware")
+        if self.status is OrderAckStatus.ACCEPTED:
+            if self.order_id is None:
+                raise ValueError("ACCEPTED 的 OrderAck 必须携带 order_id")
+            _identifier(self.order_id, "order_id")
+            if self.rejection_reason is not None:
+                raise ValueError("ACCEPTED 的 OrderAck 不允许携带 rejection_reason")
+        elif self.order_id is not None or self.rejection_reason is None:
+            raise ValueError("REJECTED 的 OrderAck 必须仅携带 rejection_reason")
+
+
+@dataclass(frozen=True, slots=True)
+class OrderSnapshot:
+    """订单聚合的不可变只读投影。"""
+
+    order_id: str
+    intent: OrderIntent
+    status: OrderStatus
+    created_event_time: datetime
+    submission_sequence: int
+    filled_quantity: int
+    average_fill_price: Decimal | None = None
+
+
+def _identifier(value: str, field_name: str) -> None:
+    if not value or value.strip() != value or any(char.isspace() for char in value):
+        raise ValueError(f"{field_name} 不允许为空或包含空白字符")
+
+
+@dataclass(frozen=True, slots=True)
+class FeeBreakdown:
+    """可核对的不可变成交费用值对象。"""
+
+    commission: Decimal
+    stamp_tax: Decimal
+    transfer_fee: Decimal
+    other: Decimal
+    total: Decimal
+
+    def __post_init__(self) -> None:
+        values = (self.commission, self.stamp_tax, self.transfer_fee, self.other, self.total)
+        if any(isinstance(value, float) for value in values):
+            raise ValueError("费用分项必须使用 Decimal，禁止 float")
+        if any(not value.is_finite() or value < 0 for value in values):
+            raise ValueError("费用分项必须是非负有限 Decimal")
+        computed = self.commission + self.stamp_tax + self.transfer_fee + self.other
+        if self.total != computed:
+            raise ValueError(f"FeeBreakdown.total {self.total} 必须严格等于分项之和 {computed}")
+
+
+@dataclass(frozen=True, slots=True)
+class TradabilityDecision:
+    """可交易性 Policy 产生的纯领域决策。"""
+
+    decision: TradabilityDecisionKind
+    defer_reason: ExecutionDeferReason | None = None
+    evidence_event_refs: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        refs = tuple(sorted(self.evidence_event_refs))
+        if len(refs) != len(set(refs)) or any(not ref for ref in refs):
+            raise ValueError("evidence_event_refs 不允许空值或重复")
+        object.__setattr__(self, "evidence_event_refs", refs)
+        if self.decision is TradabilityDecisionKind.DEFER and self.defer_reason is None:
+            raise ValueError("DEFER 决策必须携带 defer_reason")
+        if self.decision is TradabilityDecisionKind.ALLOW and self.defer_reason is not None:
+            raise ValueError("ALLOW 决策不允许携带 defer_reason")

quant_core/app/order_execution/fee_model.py

@@ -0,0 +1,60 @@
+"""Fee Model - 可注入费用模型（T5）
+
+SSOT：T5 Task「Mock Fee / Slippage 参数（2026-09-04 用户确认）」。
+
+- FeeModelProtocol 是 order_execution 消费方拥有的最小消费面；
+  SimulationBroker 只依赖 Protocol，不硬编码任何费率。
+- StandardFeeModel：Mock 确定性默认配置（佣金万三、最低 5 元、卖出印花税万五、
+  过户费 0），仅用于 Mock 回测可复现，不代表所有券商和历史时期；
+  未来按回测日期/市场/账户替换模型即可。
+- 全程 Decimal；构造边界拒绝 float 与非有限值（含字符串形式）；
+  不 quantize（与 T3 Portfolio「不二次舍入」裁定一致）。
+"""
+
+from decimal import Decimal
+from typing import cast
+
+from quant_core.app.order_execution.constants import OrderSide
+from quant_core.app.order_execution.domain.order_value import FeeBreakdown
+from quant_core.app.order_execution.validators import reject_float_amount
+
+
+class StandardFeeModel:
+    """Mock 费用模型：commission = max(notional × rate, minimum)；印花税仅 SELL"""
+
+    def __init__(
+        self,
+        commission_rate: Decimal,
+        minimum_commission: Decimal,
+        sell_stamp_tax_rate: Decimal,
+        transfer_fee_rate: Decimal,
+    ) -> None:
+        self.commission_rate = self._check_ratio(commission_rate, "commission_rate")
+        self.minimum_commission = self._check_ratio(minimum_commission, "minimum_commission")
+        self.sell_stamp_tax_rate = self._check_ratio(sell_stamp_tax_rate, "sell_stamp_tax_rate")
+        self.transfer_fee_rate = self._check_ratio(transfer_fee_rate, "transfer_fee_rate")
+
+    @staticmethod
+    def _check_ratio(value: object, field: str) -> Decimal:
+        checked = reject_float_amount(value, field)
+        ratio = checked if isinstance(checked, Decimal) else Decimal(cast(int | str, checked))
+        if not ratio.is_finite():
+            raise ValueError(f"{field} 必须是有限 Decimal，禁止字符串形式的 NaN / Infinity / sNaN")
+        if ratio < 0:
+            raise ValueError(f"{field} 必须 >= 0，实际 {ratio}")
+        return ratio
+
+    def compute(self, side: OrderSide, quantity: int, fill_price: Decimal) -> FeeBreakdown:
+        reject_float_amount(fill_price, "fill_price")
+        notional = Decimal(quantity) * fill_price
+        commission = max(notional * self.commission_rate, self.minimum_commission)
+        stamp_tax = notional * self.sell_stamp_tax_rate if side is OrderSide.SELL else Decimal("0")
+        transfer_fee = notional * self.transfer_fee_rate
+        other = Decimal("0")
+        return FeeBreakdown(
+            commission=commission,
+            stamp_tax=stamp_tax,
+            transfer_fee=transfer_fee,
+            other=other,
+            total=commission + stamp_tax + transfer_fee + other,
+        )

quant_core/app/order_execution/interface/order_account.py

@@ -0,0 +1,10 @@
+"""下单服务消费的账户契约。"""
+
+from typing import Protocol
+
+from quant_core.app.order_execution.interface.public.execution_account import IExecutionReservation
+from quant_core.app.portfolio.portfolio_schema import PortfolioSnapshot
+
+
+class IOrderAccount(IExecutionReservation, Protocol):
+    def snapshot(self) -> PortfolioSnapshot: ...

quant_core/app/order_execution/interface/order_trading_rules.py

@@ -0,0 +1,10 @@
+"""下单服务消费的交易规则契约。"""
+
+from datetime import date, datetime
+from typing import Protocol
+
+from quant_core.app.data.schema.market_schema import TradingRuleResponse
+
+
+class IOrderTradingRules(Protocol):
+    def resolve(self, instrument_id: str, at: date | datetime) -> TradingRuleResponse: ...