powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/order_execution/interface/public/execution_account.py

@@ -0,0 +1,53 @@
+"""Account capabilities consumed by order execution."""
+
+from datetime import datetime
+from decimal import Decimal
+from typing import Protocol, runtime_checkable
+
+from quant_core.app.order_execution.constants import OrderSide
+
+
+@runtime_checkable
+class IExecutionAccountView(Protocol):
+    """执行期只读账户视图（消费方拥有的最小 Port）
+
+    成交时点可用资金与可卖持仓由调用方（Runtime）注入；
+    Order Execution 不自行读取/修改 Portfolio，也不解析账户内部状态。
+    """
+
+    def available_cash(self) -> Decimal:
+        """当前可用资金（Decimal，只读）"""
+        ...
+
+    def available_quantity(self, instrument_id: str) -> int:
+        """指定标的当前可卖数量（T+1，只读）"""
+        ...
+
+
+@runtime_checkable
+class IExecutionReservation(IExecutionAccountView, Protocol):
+    """执行器用于冻结与查询订单资源的账户 Port。"""
+
+    def reserve_order(
+        self,
+        order_id: str,
+        instrument_id: str,
+        side: OrderSide,
+        quantity: int,
+        cash_amount: Decimal,
+        event_time: datetime,
+    ) -> bool:
+        """原子冻结订单所需资源；不足返回 False 且不产生部分冻结。"""
+        ...
+
+    def release_order_reservation(self, order_id: str, event_time: datetime) -> None:
+        """释放订单尚未消费的资源；重复释放幂等。"""
+        ...
+
+    def reserved_cash(self, order_id: str) -> Decimal:
+        """订单当前剩余冻结现金。"""
+        ...
+
+    def reserved_quantity(self, order_id: str) -> int:
+        """订单当前剩余冻结证券数量。"""
+        ...

quant_core/app/order_execution/interface/public/order_events.py

@@ -0,0 +1,19 @@
+"""订单事件契约：同步派发保证下单返回前账户已完成资源占用。"""
+
+from decimal import Decimal
+from typing import Protocol
+
+from quant_core.app.order_execution.domain.order_event import Fill, OrderTransition
+from quant_core.app.order_execution.domain.order_value import OrderIntent
+
+
+class IOrderEventListener(Protocol):
+    def on_order_pending_new(self, order_id: str, intent: OrderIntent, cash: Decimal) -> bool: ...
+    def on_trade(self, fill: Fill) -> None: ...
+    def on_order_update(self, update: OrderTransition) -> None: ...
+
+
+class IOrderEvents(Protocol):
+    def publish_pending_new(self, order_id: str, intent: OrderIntent, cash: Decimal) -> bool: ...
+    def publish_trade(self, fill: Fill) -> None: ...
+    def publish_order_update(self, update: OrderTransition) -> None: ...

quant_core/app/order_execution/interface/public/order_execution.py

@@ -0,0 +1,107 @@
+"""Public order-execution capability consumed by trading runtime and backtest."""
+
+from collections.abc import Mapping
+from datetime import datetime
+from decimal import Decimal
+from typing import Protocol, runtime_checkable
+
+from quant_core.app.data.schema.event_schema import CoarseBarExecutionContext, MarketTimeSlice
+from quant_core.app.data.schema.exchange_operating_state import ExchangeOperatingState
+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.execution_batch import MarketSliceProcessingResult
+from quant_core.app.order_execution.domain.order_event import OrderTransition
+from quant_core.app.order_execution.domain.order_value import OrderAck, OrderIntent, OrderSnapshot
+from quant_core.app.order_execution.interface.public.execution_account import (
+    IExecutionAccountView,
+    IExecutionReservation,
+)
+
+
+@runtime_checkable
+class IOrderExecution(Protocol):
+    """订单执行能力：同步接单，按配置在当前或后续行情撮合"""
+
+    def submit(
+        self,
+        intents: tuple[OrderIntent, ...],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        execution_context: CoarseBarExecutionContext | None = None,
+    ) -> tuple[OrderAck, ...]:
+        """提交意图批次：逐条静态校验，返回 ACCEPTED/REJECTED 回执（REJECTED 不创建 Order）
+
+        exchange_states：T4R ExchangeStateResolver 的 point-in-time 投影——
+        报单准入只消费 order_entry_allowed，本域不解释 Session 事件。
+        execution_context：T4R R3——粗粒度（日线及以上）decision point 的
+        **有界**模拟执行资格（eligible_exchanges scope + decision_time）；
+        逐条验证 Intent 落在 scope 内才放行；不是交易所运行状态事实，
+        不与 ExchangePhase 混用。
+        """
+        ...
+
+    def finish_slice(self, time_slice: MarketTimeSlice) -> tuple[OrderTransition, ...]:
+        """策略回调后的订单生命周期收尾。"""
+        ...
+
+    def expire_pending_day_orders(self, event_time: datetime) -> tuple[OrderTransition, ...]:
+        """回测终止兜底（T4R R3 finding 2 方案 C）：coarse 决策点提交的
+        PENDING DAY 单结构化 EXPIRED；日内订单不受影响（如实保留）"""
+        ...
+
+    def process_market_slice(
+        self,
+        time_slice: MarketTimeSlice,
+        market_states: Mapping[str, InstrumentMarketState],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        account_view: IExecutionAccountView,
+    ) -> MarketSliceProcessingResult:
+        """消费一个时间片，撮合此前已生效订单（新单本片绝不参与撮合）
+
+        market_states：T1 MarketStateResolver 的 point-in-time 输出；
+        exchange_states：T4R ExchangeStateResolver 的 point-in-time 投影
+        （撮合准入消费 matching_allowed，DAY 到期消费 phase==CLOSED）；
+        account_view：执行约束读取视图；账户写入由订单及成交事件监听器负责。
+        """
+        ...
+
+    def order_snapshots(self) -> tuple[OrderSnapshot, ...]:
+        """全部订单的不可变只读投影（稳定顺序）"""
+        ...
+
+    def get_order(self, order_id: str) -> OrderSnapshot | None: ...
+
+    def open_order_snapshots(
+        self, instrument_id: str | None = None
+    ) -> tuple[OrderSnapshot, ...]: ...
+
+    def cancel_order(self, order_id: str, event_time: datetime) -> OrderTransition: ...
+
+
+@runtime_checkable
+class IReservationOrderExecution(IOrderExecution, Protocol):
+    """生产 Runtime 使用的原子资源预占扩展能力。"""
+
+    def match_current_slice(
+        self, account_view: IExecutionAccountView
+    ) -> MarketSliceProcessingResult:
+        """在当前行情上处理当前 Bar 模式的订单。"""
+        ...
+
+    def estimate_transaction_cost(self, side: OrderSide, quantity: int, price: Decimal) -> Decimal:
+        """按当前费用模型估计交易成本。"""
+        ...
+
+    def estimate_order_cash(self, intent: OrderIntent, reference_price: Decimal) -> Decimal:
+        """按报单冻结口径估算现金，供金额下单复用。"""
+        ...
+
+    def submit_with_reservation(
+        self,
+        intents: tuple[OrderIntent, ...],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        account_view: IExecutionReservation,
+        reference_prices: Mapping[str, Decimal],
+        execution_context: CoarseBarExecutionContext | None = None,
+    ) -> tuple[OrderAck, ...]:
+        """提交并原子冻结资源；Runtime 生产链使用此入口。"""
+        ...

quant_core/app/order_execution/interface/public/order_runtime.py

@@ -0,0 +1,30 @@
+"""运行环境消费的行情注入与交易记录契约。"""
+
+from collections.abc import Mapping
+from decimal import Decimal
+from typing import Protocol
+
+from quant_core.app.data.schema.event_schema import MarketTimeSlice
+from quant_core.app.data.schema.exchange_operating_state import ExchangeOperatingState
+from quant_core.app.order_execution.domain.execution_batch import MarketSliceProcessingResult
+from quant_core.app.order_execution.domain.order_event import OrderTransition
+from quant_core.app.order_execution.domain.order_value import OrderAck, OrderIntent
+from quant_core.app.order_execution.interface.public.order_submission import IOrderSubmission
+from quant_core.app.order_execution.schema.order_request_schema import OrderRequest
+
+
+class IOrderRuntime(IOrderSubmission, Protocol):
+    """运行环境的行情注入与交易审计能力；审计内容不驱动订单执行。"""
+
+    requests: list[OrderRequest]
+    intents: list[OrderIntent]
+    acks: list[OrderAck]
+    cancellations: list[OrderTransition]
+    matches: list[MarketSliceProcessingResult]
+
+    def begin_slice(
+        self,
+        time_slice: MarketTimeSlice,
+        prices: Mapping[str, Decimal],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+    ) -> None: ...

quant_core/app/order_execution/interface/public/order_submission.py

@@ -0,0 +1,17 @@
+"""策略消费的同步交易能力；返回实际订单，未创建订单返回 None。"""
+
+from collections.abc import Mapping
+from datetime import datetime
+from decimal import Decimal
+from typing import Protocol
+
+from quant_core.app.order_execution.domain.order_value import OrderSnapshot
+from quant_core.app.order_execution.schema.order_request_schema import OrderRequest
+
+
+class IOrderSubmission(Protocol):
+    def submit(self, request: OrderRequest) -> OrderSnapshot | None: ...
+    def order_target_portfolio(
+        self, strategy_id: str, targets: Mapping[str, Decimal], event_time: datetime
+    ) -> tuple[OrderSnapshot, ...]: ...
+    def cancel_order(self, order_id: str, event_time: datetime) -> None: ...

quant_core/app/order_execution/order_event_bus.py

@@ -0,0 +1,28 @@
+"""同步订单事件分发；监听器顺序由运行组装点决定。"""
+
+from collections.abc import Sequence
+from decimal import Decimal
+
+from quant_core.app.order_execution.domain.order_event import Fill, OrderTransition
+from quant_core.app.order_execution.domain.order_value import OrderIntent
+from quant_core.app.order_execution.interface.public.order_events import IOrderEventListener
+
+
+class OrderEventBus:
+    """每次运行独立持有监听器，不使用进程级全局账户。"""
+
+    def __init__(self, listeners: Sequence[IOrderEventListener]) -> None:
+        self._listeners = tuple(listeners)
+
+    def publish_pending_new(self, order_id: str, intent: OrderIntent, cash: Decimal) -> bool:
+        return all(
+            listener.on_order_pending_new(order_id, intent, cash) for listener in self._listeners
+        )
+
+    def publish_trade(self, fill: Fill) -> None:
+        for listener in self._listeners:
+            listener.on_trade(fill)
+
+    def publish_order_update(self, update: OrderTransition) -> None:
+        for listener in self._listeners:
+            listener.on_order_update(update)

quant_core/app/order_execution/order_execution_dependency.py

@@ -0,0 +1,48 @@
+"""Order Execution 所属域的模拟执行组装入口。"""
+
+from decimal import Decimal
+
+from quant_core.app.order_execution.constants import ExecutionPolicy
+from quant_core.app.order_execution.fee_model import StandardFeeModel
+from quant_core.app.order_execution.interface.order_account import IOrderAccount
+from quant_core.app.order_execution.interface.order_trading_rules import IOrderTradingRules
+from quant_core.app.order_execution.interface.public.order_events import IOrderEventListener
+from quant_core.app.order_execution.interface.public.order_execution import (
+    IReservationOrderExecution,
+)
+from quant_core.app.order_execution.interface.public.order_runtime import IOrderRuntime
+from quant_core.app.order_execution.order_event_bus import OrderEventBus
+from quant_core.app.order_execution.order_submission_service import OrderSubmissionService
+from quant_core.app.order_execution.simulation_broker import SimulationBroker
+from quant_core.app.order_execution.slippage_model import FixedBpsSlippageModel
+from quant_core.app.order_execution.tradability_policy import ChinaEquityTradabilityPolicy
+
+
+def build_simulated_execution(
+    slippage_bps: Decimal, policy: ExecutionPolicy, listener: IOrderEventListener
+) -> IReservationOrderExecution:
+    """复用当前费率、准入与成交模型，向调用方只暴露执行接口。"""
+    return SimulationBroker(
+        tradability_policy=ChinaEquityTradabilityPolicy(),
+        fee_model=StandardFeeModel(
+            commission_rate=Decimal("0.0003"),
+            minimum_commission=Decimal("5"),
+            sell_stamp_tax_rate=Decimal("0.0005"),
+            transfer_fee_rate=Decimal("0"),
+        ),
+        slippage_model=FixedBpsSlippageModel(slippage_bps),
+        reservation_enabled=True,
+        events=OrderEventBus((listener,)),
+        max_volume_participation=Decimal("0.25"),
+    )
+
+
+def build_order_api(
+    broker: IReservationOrderExecution,
+    account: IOrderAccount,
+    rules: IOrderTradingRules,
+    policy: ExecutionPolicy,
+    auto_switch_order_value: bool = False,
+) -> IOrderRuntime:
+    """组装同步下单入口，与 Broker 共享账户与费用口径。"""
+    return OrderSubmissionService(broker, account, rules, policy, auto_switch_order_value)

quant_core/app/order_execution/order_submission_service.py

@@ -0,0 +1,301 @@
+"""同步交易 API：目标与金额换算在调用内完成，立即向 Broker 提交。
+
+行为基准：RQAlpha api_stock 的数量、金额与目标下单；本服务不维护调仓任务。
+"""
+
+from collections.abc import Mapping
+from datetime import datetime
+from decimal import Decimal
+
+from quant_core.app.data.schema.event_schema import MarketTimeSlice
+from quant_core.app.data.schema.exchange_operating_state import ExchangeOperatingState
+from quant_core.app.order_execution.constants import (
+    ExecutionPolicy,
+    OrderAckStatus,
+    OrderRejectReason,
+    OrderSide,
+    OrderType,
+)
+from quant_core.app.order_execution.domain.execution_batch import MarketSliceProcessingResult
+from quant_core.app.order_execution.domain.order_event import OrderTransition
+from quant_core.app.order_execution.domain.order_value import OrderAck, OrderIntent, OrderSnapshot
+from quant_core.app.order_execution.interface.order_account import IOrderAccount
+from quant_core.app.order_execution.interface.order_trading_rules import IOrderTradingRules
+from quant_core.app.order_execution.interface.public.order_execution import (
+    IReservationOrderExecution,
+)
+from quant_core.app.order_execution.schema.order_request_schema import (
+    OrderRequest,
+    OrderRequestType,
+)
+
+
+class OrderSubmissionService:
+    """按当前账户状态处理下单；记录只用于审计，绝不驱动后续自动重试。"""
+
+    def __init__(
+        self,
+        broker: IReservationOrderExecution,
+        account: IOrderAccount,
+        trading_rules: IOrderTradingRules,
+        execution_policy: ExecutionPolicy = ExecutionPolicy.NEXT_BAR_OPEN,
+        auto_switch_order_value: bool = False,
+    ) -> None:
+        self._broker = broker
+        self._account = account
+        self._rules = trading_rules
+        self._policy = execution_policy
+        self._auto_switch = auto_switch_order_value
+        self._slice: MarketTimeSlice | None = None
+        self._prices: dict[str, Decimal] = {}
+        self._exchange_states: dict[str, ExchangeOperatingState] = {}
+        self.requests: list[OrderRequest] = []
+        self.intents: list[OrderIntent] = []
+        self.acks: list[OrderAck] = []
+        self.cancellations: list[OrderTransition] = []
+        self.matches: list[MarketSliceProcessingResult] = []
+
+    def begin_slice(
+        self,
+        time_slice: MarketTimeSlice,
+        prices: Mapping[str, Decimal],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+    ) -> None:
+        """由运行环境注入当前市场事实，清空上片审计记录。"""
+        self._slice = time_slice
+        self._prices.update(prices)
+        self._exchange_states = dict(exchange_states)
+        self.requests.clear()
+        self.intents.clear()
+        self.acks.clear()
+        self.cancellations.clear()
+        self.matches.clear()
+
+    def submit(self, request: OrderRequest) -> OrderSnapshot | None:
+        """同步换算、验资和提交；返回已创建订单，失败或无须调整返回 None。"""
+        if self._slice is None or request.event_time != self._slice.event_time:
+            raise ValueError("下单时间必须等于当前市场时间")
+        self.requests.append(request)
+        price = self._prices.get(request.instrument_id)
+        if price is None or price <= 0:
+            return self._reject(request, OrderRejectReason.MISSING_REFERENCE_PRICE)
+        snapshot = self._account.snapshot()
+        position = next(
+            (p for p in snapshot.positions if p.instrument_id == request.instrument_id), None
+        )
+        held = position.quantity if position else 0
+        market_value = position.market_value if position else Decimal(0)
+        rule = self._rules.resolve(request.instrument_id, request.event_time).quantity_rule
+        kind = request.request_type
+        if kind in {OrderRequestType.QUANTITY, OrderRequestType.TARGET_QUANTITY}:
+            assert request.quantity is not None
+            delta = request.quantity - (held if kind is OrderRequestType.TARGET_QUANTITY else 0)
+            cash_limited = self._auto_switch
+        else:
+            amount = request.value
+            if kind is OrderRequestType.TARGET_PERCENT:
+                assert request.target_percent is not None
+                amount = snapshot.total_value * request.target_percent
+            assert amount is not None
+            if kind in {OrderRequestType.TARGET_VALUE, OrderRequestType.TARGET_PERCENT}:
+                if amount == 0:
+                    delta = -self._account.available_quantity(request.instrument_id)
+                    return self._submit_quantity(request, delta)
+                amount -= market_value
+            unit_price = request.limit_price or price
+            delta = int(amount / unit_price)
+            if delta < 0:
+                delta = -min(-delta, self._account.available_quantity(request.instrument_id))
+            cash_limited = True
+        if delta == 0:
+            return None
+        if delta > 0:
+            quantity = rule.buy_quantity(delta)
+        elif -delta == held:
+            quantity = delta
+        else:
+            requested = -delta
+            quantity = -(requested // rule.sell_quantity_step * rule.sell_quantity_step)
+            if -quantity < rule.min_sell_quantity:
+                quantity = 0
+        if quantity > 0 and cash_limited:
+            budget = self._account.available_cash()
+            # 金额单的预算包含交易费用；数量单仅在显式配置时允许缩量。
+            if kind not in {OrderRequestType.QUANTITY, OrderRequestType.TARGET_QUANTITY}:
+                budget = min(budget, max(Decimal(0), amount))
+            quantity = self._affordable(request, quantity, budget)
+        return self._submit_quantity(request, quantity)
+
+    def order_target_portfolio(
+        self,
+        strategy_id: str,
+        targets: Mapping[str, Decimal],
+        event_time: datetime,
+    ) -> tuple[OrderSnapshot, ...]:
+        """对应 api_stock.order_target_portfolio 的当次批量调整。
+
+        全仓目标先扣估计费用；目标差额按交易单位就近取整，先提交卖单。
+        买单预算估计允许计入本次卖出所得，但 Broker 验资仍使用真实可用现金。
+        """
+        if self._slice is None or event_time != self._slice.event_time:
+            raise ValueError("下单时间必须等于当前市场时间")
+        if any(not isinstance(w, Decimal) or not w.is_finite() or w < 0 for w in targets.values()):
+            raise ValueError("目标权重必须是非负有限 Decimal")
+        if sum(targets.values(), Decimal(0)) > 1:
+            raise ValueError("目标权重合计不得超过 1")
+        # 参数和交易规则验证先于任何报单，避免非法输入引起部分执行。
+        for key, weight in targets.items():
+            OrderRequest(
+                strategy_id=strategy_id,
+                instrument_id=key,
+                request_type=OrderRequestType.TARGET_PERCENT,
+                target_percent=weight,
+                event_time=event_time,
+            )
+            self._rules.resolve(key, event_time)
+        snapshot = self._account.snapshot()
+        positions = {p.instrument_id: p for p in snapshot.positions}
+        valid = {
+            key: weight for key, weight in targets.items() if self._prices.get(key, Decimal(0)) > 0
+        }
+        orders: list[OrderSnapshot] = []
+        for key, position in positions.items():
+            if key not in valid:
+                request = OrderRequest(
+                    strategy_id=strategy_id,
+                    instrument_id=key,
+                    request_type=OrderRequestType.QUANTITY,
+                    quantity=-position.quantity,
+                    event_time=event_time,
+                )
+                order = self.submit(request)
+                if order is not None:
+                    orders.append(order)
+        value = self._account.snapshot().total_value
+        if sum(valid.values(), Decimal(0)) == 1:
+            cost = Decimal(0)
+            for key, weight in valid.items():
+                price = self._prices[key]
+                held = positions[key].quantity if key in positions else 0
+                delta = int(value * weight / price) - held
+                if delta:
+                    cost += self._broker.estimate_transaction_cost(
+                        OrderSide.BUY if delta > 0 else OrderSide.SELL, abs(delta), price
+                    )
+            value -= cost
+        selling: list[tuple[str, int]] = []
+        buying: list[tuple[str, int]] = []
+        for key, weight in valid.items():
+            held = positions[key].quantity if key in positions else 0
+            delta = value * weight / self._prices[key] - held
+            rule = self._rules.resolve(key, event_time).quantity_rule
+            step = rule.buy_quantity_step if delta > 0 else rule.sell_quantity_step
+            quantity = int(round(abs(delta) / step)) * step
+            minimum = rule.min_buy_quantity if delta > 0 else rule.min_sell_quantity
+            if quantity < minimum:
+                continue
+            (buying if delta > 0 else selling).append((key, quantity))
+        estimated_cash = self._account.available_cash()
+        for key, quantity in selling:
+            estimated_cash += quantity * self._prices[key] - self._broker.estimate_transaction_cost(
+                OrderSide.SELL, quantity, self._prices[key]
+            )
+        buy_quantities: list[tuple[str, int]] = []
+        for key, quantity in buying:
+            price = self._prices[key]
+            cost = quantity * price + self._broker.estimate_transaction_cost(
+                OrderSide.BUY, quantity, price
+            )
+            if cost > estimated_cash:
+                rule = self._rules.resolve(key, event_time).quantity_rule
+                quantity = rule.buy_quantity(max(0, int(estimated_cash / price)))
+                if not quantity:
+                    continue
+                cost = quantity * price + self._broker.estimate_transaction_cost(
+                    OrderSide.BUY, quantity, price
+                )
+            buy_quantities.append((key, quantity))
+            estimated_cash -= cost
+        for side, quantities in ((OrderSide.SELL, selling), (OrderSide.BUY, buy_quantities)):
+            for key, quantity in quantities:
+                request = OrderRequest(
+                    strategy_id=strategy_id,
+                    instrument_id=key,
+                    request_type=OrderRequestType.QUANTITY,
+                    quantity=quantity if side is OrderSide.BUY else -quantity,
+                    event_time=event_time,
+                )
+                self.requests.append(request)
+                order = self._submit_quantity(
+                    request, quantity if side is OrderSide.BUY else -quantity
+                )
+                if order is not None:
+                    orders.append(order)
+        return tuple(orders)
+
+    def cancel_order(self, order_id: str, event_time: datetime) -> None:
+        """同步撤单并释放剩余冻结，使同一回调的后续下单可使用资源。"""
+        if self._slice is None or self._slice.event_time != event_time:
+            raise ValueError("撤单时间必须等于当前市场时间")
+        update = self._broker.cancel_order(order_id, event_time)
+        self.cancellations.append(update)
+
+    def _affordable(self, request: OrderRequest, maximum: int, budget: Decimal) -> int:
+        rule = self._rules.resolve(request.instrument_id, request.event_time).quantity_rule
+        low, high = 0, maximum
+        while low < high:
+            middle = (low + high + 1) // 2
+            quantity = rule.buy_quantity(middle)
+            if (
+                quantity == 0
+                or self._broker.estimate_order_cash(
+                    self._intent(request, quantity), self._prices[request.instrument_id]
+                )
+                <= budget
+            ):
+                low = middle
+            else:
+                high = middle - 1
+        return rule.buy_quantity(low)
+
+    def _intent(self, request: OrderRequest, quantity: int) -> OrderIntent:
+        return OrderIntent(
+            intent_id=request.request_id,
+            strategy_id=request.strategy_id,
+            instrument_id=request.instrument_id,
+            side=OrderSide.BUY if quantity > 0 else OrderSide.SELL,
+            quantity=abs(quantity),
+            creation_event_time=request.event_time,
+            order_type=OrderType.LIMIT if request.limit_price is not None else OrderType.MARKET,
+            limit_price=request.limit_price,
+            execution_policy=self._policy,
+            signal_refs=request.signal_refs,
+        )
+
+    def _submit_quantity(self, request: OrderRequest, quantity: int) -> OrderSnapshot | None:
+        if quantity == 0:
+            return None
+        assert self._slice is not None
+        intent = self._intent(request, quantity)
+        self.intents.append(intent)
+        (ack,) = self._broker.submit_with_reservation(
+            (intent,),
+            self._exchange_states,
+            self._account,
+            self._prices,
+            self._slice.execution_context,
+        )
+        self.acks.append(ack)
+        if ack.order_id and self._policy is ExecutionPolicy.CURRENT_BAR_CLOSE:
+            self.matches.append(self._broker.match_current_slice(self._account))
+        return self._broker.get_order(ack.order_id) if ack.order_id else None
+
+    def _reject(self, request: OrderRequest, reason: OrderRejectReason) -> None:
+        self.acks.append(
+            OrderAck(
+                intent_id=request.request_id,
+                status=OrderAckStatus.REJECTED,
+                event_time=request.event_time,
+                rejection_reason=reason,
+            )
+        )