back-trader-python 1.4.0__py3-none-any.whl

backtrader/brokers/hft/exchange.py

@@ -0,0 +1,380 @@
+"""Exchange matching models for HFT simulation.
+
+Defines :class:`ExchangeModel` and concrete variants that decide how an order
+interacts with an order book / trade stream (maker vs taker fills, rejections),
+plus :class:`FillRole` and :class:`OrderResult`. Used by the tick broker's
+matching core.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+from backtrader.order import Order
+
+from .queue import ProbQueueModel
+
+
+class FillRole(Enum):
+    """Side of liquidity the order provided when it got filled.
+
+    Attributes:
+        MAKER: The order was resting on the book and provided liquidity.
+        TAKER: The order aggressed against the book and consumed liquidity.
+    """
+
+    MAKER = "maker"
+    TAKER = "taker"
+
+
+@dataclass
+class OrderResult:
+    """Outcome of an exchange model's processing of an order.
+
+    Attributes:
+        action: High-level outcome keyword. One of ``"FILL"`` (the order was
+            fully or partially filled), ``"PENDING"`` (the order is resting on
+            the book and may fill later) or ``"REJECT"`` (the order was
+            rejected, see ``reject_reason`` for the reason code).
+        fills: List of fill tuples produced for this order. Each tuple's
+            shape is model-specific; for example,
+            :class:`SimpleExchangeModel` uses ``(price, quantity, role)``
+            while :class:`QueueExchangeModel` prepends the originating
+            ``order`` object.
+        reject_reason: Short code explaining the rejection, populated when
+            ``action == "REJECT"``. Empty otherwise.
+    """
+
+    action: str
+    fills: list = field(default_factory=list)
+    reject_reason: str = ""
+
+
+class ExchangeModel:
+    """Abstract interface for exchange matching behavior.
+
+    Subclasses describe how an incoming order interacts with the current
+    order book and trade stream, and how subsequent market data updates
+    drive fills. All three hook methods receive a snapshot/pending-orders
+    view from the matching core.
+    """
+
+    def on_new_order(self, order, ob_snapshot):
+        """Handle a newly accepted order against ``ob_snapshot``.
+
+        Subclasses must implement this and return an :class:`OrderResult`
+        describing whether the order was filled, pended, or rejected.
+
+        Args:
+            order: The newly accepted order. Provides ``exectype``,
+                ``isbuy()``, ``price`` and ``size`` accessors.
+            ob_snapshot: Order book snapshot at the time the order was
+                accepted. Provides ``bids`` and ``asks``.
+
+        Returns:
+            OrderResult: Outcome of the matching attempt.
+        """
+        raise NotImplementedError
+
+    def on_trade(self, trade_event, pending_orders):
+        """Process a trade event for any resting pending orders.
+
+        Subclasses may consume the trade and emit maker-style fills when
+        one of the ``pending_orders`` was at the trade price.
+
+        Args:
+            trade_event: The trade event to consume. Provides ``price`` and
+                ``volume``.
+            pending_orders: Iterable of resting orders that may be filled by
+                this trade.
+
+        Returns:
+            list: Fill tuples produced by the subclass (possibly empty).
+        """
+        raise NotImplementedError
+
+    def on_depth_update(self, ob_event, pending_orders):
+        """Process a depth update to refresh queue-ahead estimates.
+
+        The default implementation is a no-op. Models that track per-order
+        queue position (e.g. :class:`QueueExchangeModel`) override this to
+        reconcile each resting order's queue-ahead against the new depth.
+
+        Args:
+            ob_event: Depth update event. May carry ``previous_bids`` /
+                ``previous_asks`` and ``bids`` / ``asks``.
+            pending_orders: Iterable of resting orders that may be affected
+                by the depth update.
+
+        Returns:
+            list: Fill tuples produced by the subclass (possibly empty).
+        """
+        _ = (ob_event, pending_orders)
+        return []
+
+
+class SimpleExchangeModel(ExchangeModel):
+    """Exchange model that walks the book level-by-level with no queueing.
+
+    Market orders sweep liquidity against the opposite side of the book.
+    Limit orders either fill immediately if they cross the spread or sit
+    pending without any queue-position tracking. This model is the right
+    choice when queue dynamics are not needed (e.g. fast smoke tests).
+    """
+
+    def on_new_order(self, order, ob_snapshot):
+        """Match a new order against the current book with no queueing.
+
+        Market orders are filled against the opposite side; limit orders
+        that cross the spread are matched as takers. Limit orders that do
+        not cross the spread are returned as ``PENDING``.
+
+        Args:
+            order: The newly accepted order.
+            ob_snapshot: Order book snapshot at acceptance.
+
+        Returns:
+            OrderResult: ``"FILL"`` with taker fills when the order matches
+            against depth, otherwise ``"PENDING"``.
+        """
+        if order.exectype == Order.Market:
+            return self._match_against_depth(order, ob_snapshot, FillRole.TAKER)
+        if order.exectype == Order.Limit and self._crosses_spread(order, ob_snapshot):
+            return self._match_against_depth(order, ob_snapshot, FillRole.TAKER)
+        return OrderResult(action="PENDING")
+
+    def on_trade(self, trade_event, pending_orders):
+        """Ignore trade events (queueing is not simulated).
+
+        Args:
+            trade_event: The trade event (unused).
+            pending_orders: The resting orders (unused).
+
+        Returns:
+            list: Always empty for this model.
+        """
+        _ = (trade_event, pending_orders)
+        return []
+
+    def _crosses_spread(self, order, ob_snapshot):
+        """Return True when the order's limit price crosses the best quote.
+
+        A buy limit crosses when its price is greater than or equal to the
+        best ask; a sell limit crosses when its price is less than or equal
+        to the best bid.
+
+        Args:
+            order: The order being evaluated. Must expose ``isbuy()`` and
+                ``price``.
+            ob_snapshot: Order book snapshot providing ``bids`` and
+                ``asks``.
+
+        Returns:
+            bool: ``True`` if the limit order can be filled immediately.
+        """
+        if order.isbuy():
+            best_ask = ob_snapshot.asks[0][0] if ob_snapshot.asks else None
+            return best_ask is not None and order.price >= best_ask
+        best_bid = ob_snapshot.bids[0][0] if ob_snapshot.bids else None
+        return best_bid is not None and order.price <= best_bid
+
+    def _match_against_depth(self, order, ob_snapshot, role):
+        """Walk the book and fill the order as a taker up to its size.
+
+        Market orders consume every level until the size is met; limit
+        orders stop when the next level's price is on the wrong side of
+        ``order.price``.
+
+        Args:
+            order: The aggressive order to fill. Provides ``isbuy()``,
+                ``size`` and, for limits, ``price``.
+            ob_snapshot: Order book snapshot to consume.
+            role: The :class:`FillRole` to attach to each fill produced
+                (typically :attr:`FillRole.TAKER`).
+
+        Returns:
+            OrderResult: ``"FILL"`` with the per-level fills when at least
+            one level matched, otherwise ``"PENDING"``.
+        """
+        levels = ob_snapshot.asks if order.isbuy() else ob_snapshot.bids
+        remaining = getattr(getattr(order, "executed", None), "remsize", None)
+        if remaining is None:
+            remaining = getattr(order, "size", 0.0)
+        remaining = abs(remaining)
+        fills = []
+        for price, qty in levels:
+            if order.exectype == Order.Limit:
+                if order.isbuy() and price > order.price:
+                    break
+                if not order.isbuy() and price < order.price:
+                    break
+            fill_qty = min(remaining, qty)
+            if fill_qty <= 0:
+                continue
+            fills.append((price, fill_qty, role))
+            remaining -= fill_qty
+            if remaining <= 0:
+                break
+        if not fills:
+            return OrderResult(action="PENDING")
+        return OrderResult(action="FILL", fills=fills)
+
+
+class QueueExchangeModel(SimpleExchangeModel):
+    """Exchange model that maintains per-order queue position for maker fills.
+
+    Limit orders that cross the spread follow :class:`SimpleExchangeModel`'s
+    taker semantics (with extra handling for ``GTX``/``FOK`` time-in-force
+    flags). Limit orders that do not cross the spread are parked as maker
+    orders and their queue-ahead is tracked via the injected queue model
+    as trades and depth updates arrive.
+    """
+
+    def __init__(
+        self,
+        queue_model=None,
+        queue_model_power: float = 2.0,
+        lot_size: float = 1.0,
+        tick_size: float = None,
+    ):
+        """Initialize the queue-aware exchange model.
+
+        Args:
+            queue_model: Optional pre-built queue model. When ``None``, a
+                :class:`backtrader.brokers.hft.queue.ProbQueueModel` is
+                constructed from ``queue_model_power`` and ``lot_size``.
+            queue_model_power: Power exponent forwarded to the default
+                :class:`ProbQueueModel` when ``queue_model`` is ``None``.
+            lot_size: Default lot size forwarded to the default
+                :class:`ProbQueueModel` when ``queue_model`` is ``None``.
+            tick_size: Optional price tick size. When provided, price
+                equality is computed after rounding to this granularity so
+                floating-point noise does not break maker/trade matching.
+                ``None`` disables tick-based matching.
+        """
+        self._queue_model = queue_model or ProbQueueModel(
+            power=queue_model_power, lot_size=lot_size
+        )
+        self._tick_size = float(tick_size) if tick_size is not None else None
+
+    def on_new_order(self, order, ob_snapshot):
+        """Park the order as a maker or fill it as a taker.
+
+        Market orders are filled against depth. Crossing limit orders
+        follow the taker path and honor ``GTX`` (reject when crossing)
+        and ``FOK`` (reject when the full size cannot be filled) flags.
+        Non-crossing limit orders are recorded by the queue model and
+        returned as ``PENDING`` with the ``_fill_role`` tag set to
+        :attr:`FillRole.MAKER`.
+
+        Args:
+            order: The newly accepted order.
+            ob_snapshot: Order book snapshot at acceptance.
+
+        Returns:
+            OrderResult: ``"FILL"`` for takers, ``"PENDING"`` for resting
+            makers, or ``"REJECT"`` for ``GTX``/``FOK`` violations.
+        """
+        if order.exectype == Order.Market:
+            return self._match_against_depth(order, ob_snapshot, FillRole.TAKER)
+
+        if order.exectype == Order.Limit:
+            if self._crosses_spread(order, ob_snapshot):
+                tif = getattr(order, "time_in_force", "GTC")
+                taker_result = self._match_against_depth(order, ob_snapshot, FillRole.TAKER)
+                filled_qty = sum(fill[1] for fill in taker_result.fills)
+                order_qty = abs(getattr(order, "size", 0.0))
+                if tif == "GTX":
+                    return OrderResult(action="REJECT", reject_reason="GTX_CROSSED")
+                if tif == "FOK" and filled_qty < order_qty:
+                    return OrderResult(action="REJECT", reject_reason="FOK_INSUFFICIENT")
+                return taker_result
+
+            self._queue_model.on_new_order(order, ob_snapshot)
+            order._fill_role = FillRole.MAKER
+            return OrderResult(action="PENDING")
+
+        return OrderResult(action="PENDING")
+
+    def on_trade(self, trade_event, pending_orders):
+        """Drive maker fills from incoming trade events.
+
+        For each resting maker order, check whether the trade price
+        matches the order's price (within ``_tick_size`` if configured) and,
+        if so, delegate to the queue model's ``update_on_trade``. Any
+        resulting fill is appended in the form
+        ``(order, price, quantity, role)``.
+
+        Args:
+            trade_event: The trade event to consume. Provides ``price`` and
+                ``volume``.
+            pending_orders: Resting orders that may be filled by this trade.
+
+        Returns:
+            list: ``(order, price, fillable_qty, FillRole.MAKER)`` tuples
+            for orders that filled, possibly empty.
+        """
+        fills = []
+        for order in pending_orders:
+            if getattr(order, "_fill_role", None) != FillRole.MAKER:
+                continue
+            trade_price = getattr(trade_event, "price", None)
+            order_price = getattr(order, "price", None)
+            if trade_price is None or order_price is None:
+                continue
+            if self._tick_size is not None and self._tick_size > 0:
+                if round(float(trade_price) / self._tick_size) != round(
+                    float(order_price) / self._tick_size
+                ):
+                    continue
+            elif float(trade_price) != float(order_price):
+                continue
+            fillable = self._queue_model.update_on_trade(order, trade_event)
+            if fillable > 0:
+                fills.append((order, trade_price, fillable, FillRole.MAKER))
+        return fills
+
+    def on_depth_update(self, ob_event, pending_orders):
+        """Refresh each maker order's queue-ahead from the new depth.
+
+        For every resting maker order, compute the previous and current
+        depth at the order's price (respecting ``_tick_size``) and forward
+        the pair to the queue model's ``update_on_depth``.
+
+        Args:
+            ob_event: Depth update event providing ``previous_bids`` /
+                ``previous_asks`` (or empty) and ``bids`` / ``asks``.
+            pending_orders: Resting orders to reconcile.
+
+        Returns:
+            list: Always empty in the current implementation; the method
+            is called for its side effect of updating queue-ahead state.
+        """
+        fills: list = []
+        prev_bids = getattr(ob_event, "previous_bids", None) or []
+        prev_asks = getattr(ob_event, "previous_asks", None) or []
+        curr_bids = getattr(ob_event, "bids", None) or []
+        curr_asks = getattr(ob_event, "asks", None) or []
+
+        def level_qty(levels, price):
+            for level_price, level_qty_value in levels:
+                if self._tick_size is not None and self._tick_size > 0:
+                    if round(float(level_price) / self._tick_size) == round(
+                        float(price) / self._tick_size
+                    ):
+                        return float(level_qty_value)
+                elif float(level_price) == float(price):
+                    return float(level_qty_value)
+            return 0.0
+
+        for order in pending_orders:
+            if getattr(order, "_fill_role", None) != FillRole.MAKER:
+                continue
+            price = getattr(order, "price", None)
+            if price is None:
+                continue
+            prev_qty = level_qty(prev_bids if order.isbuy() else prev_asks, price)
+            new_qty = level_qty(curr_bids if order.isbuy() else curr_asks, price)
+            if abs(prev_qty - new_qty) <= 1e-12:
+                continue
+            self._queue_model.update_on_depth(order, prev_qty, new_qty)
+        return fills

backtrader/brokers/hft/latency.py

@@ -0,0 +1,309 @@
+"""Latency models for HFT simulation.
+
+Defines :class:`LatencyModel` and implementations (e.g.
+:class:`ConstantLatencyModel`) that model feed, order-entry and order-response
+delays so the tick matching engine can simulate realistic exchange round-trips.
+"""
+
+import bisect
+import heapq
+import math
+
+
+class LatencyModel:
+    """Abstract interface for exchange round-trip latency models.
+
+    A latency model returns, in seconds, how much delay a market-data feed,
+    an order entry or an order response should incur. The three methods are
+    kept separate so models can differentiate feed jitter from order-entry
+    latency from exchange ack latency.
+    """
+
+    def feed_latency(self, exch_ts, symbol):
+        """Return the feed latency (in seconds) for ``symbol`` at ``exch_ts``.
+
+        Args:
+            exch_ts: Exchange-side timestamp of the market-data event.
+            symbol: Symbol the event is for.
+
+        Returns:
+            float: Latency in seconds to be added to ``exch_ts`` to obtain
+            the local time at which the event is observed.
+        """
+        raise NotImplementedError
+
+    def order_entry_latency(self, local_ts, symbol):
+        """Return the order-entry latency (in seconds) for ``symbol``.
+
+        Args:
+            local_ts: Local time at which the order is submitted.
+            symbol: Symbol the order is for.
+
+        Returns:
+            float: Latency in seconds between local submission and the
+            order being visible to the exchange.
+        """
+        raise NotImplementedError
+
+    def order_response_latency(self, exch_ts, symbol):
+        """Return the order-response latency (in seconds) for ``symbol``.
+
+        Args:
+            exch_ts: Exchange-side timestamp of the acknowledgement.
+            symbol: Symbol the response is for.
+
+        Returns:
+            float: Latency in seconds between the exchange producing the
+            response and it being received locally.
+        """
+        raise NotImplementedError
+
+
+class ConstantLatencyModel(LatencyModel):
+    """Constant-latency model: a single value per stage, regardless of time.
+
+    All three stages (feed, order entry, order response) use fixed
+    per-stage values supplied in milliseconds at construction time. This
+    is the simplest model and is typically used for deterministic tests.
+    """
+
+    def __init__(self, feed_latency_ms=0, order_entry_latency_ms=0, order_response_latency_ms=0):
+        """Initialize the constant-latency model.
+
+        Args:
+            feed_latency_ms: Feed latency in milliseconds (default ``0``).
+            order_entry_latency_ms: Order-entry latency in milliseconds
+                (default ``0``).
+            order_response_latency_ms: Order-response latency in
+                milliseconds (default ``0``).
+        """
+        self._feed_lat = feed_latency_ms / 1000.0
+        self._entry_lat = order_entry_latency_ms / 1000.0
+        self._resp_lat = order_response_latency_ms / 1000.0
+
+    def feed_latency(self, exch_ts, symbol):
+        """Return the configured constant feed latency in seconds."""
+        _ = (exch_ts, symbol)
+        return self._feed_lat
+
+    def order_entry_latency(self, local_ts, symbol):
+        """Return the configured constant order-entry latency in seconds."""
+        _ = (local_ts, symbol)
+        return self._entry_lat
+
+    def order_response_latency(self, exch_ts, symbol):
+        """Return the configured constant order-response latency in seconds."""
+        _ = (exch_ts, symbol)
+        return self._resp_lat
+
+
+class IntpLatencyModel(LatencyModel):
+    """Time-varying latency model that linearly interpolates measured samples.
+
+    Accepts a sequence of ``(timestamp, feed, entry, resp)`` rows. The
+    rows are sorted by timestamp at construction time and lookups for an
+    arbitrary query time are performed via linear interpolation between
+    the two surrounding samples. The optional ``latency_offset`` is added
+    to the query timestamp before lookup, so the same data set can be
+    time-shifted without rebuilding the model.
+    """
+
+    def __init__(self, latency_data, latency_offset=0.0):
+        """Initialize the interpolated latency model.
+
+        Args:
+            latency_data: Iterable of ``(timestamp, feed_latency,
+                entry_latency, resp_latency)`` rows. The first column is
+                the exchange-side timestamp (in seconds), the other three
+                are the corresponding stage latencies in seconds.
+            latency_offset: Optional offset (in seconds) added to the
+                query timestamp before the binary search; useful for
+                time-shifting an existing profile.
+        """
+        self._offset = float(latency_offset)
+        rows = sorted(
+            (float(row[0]), float(row[1]), float(row[2]), float(row[3])) for row in latency_data
+        )
+        self._ts = [row[0] for row in rows]
+        self._feed = [row[1] for row in rows]
+        self._entry = [row[2] for row in rows]
+        self._resp = [row[3] for row in rows]
+
+    def _interp(self, ts, values):
+        """Linearly interpolate ``values`` at the time-shifted query time.
+
+        Returns the first sample for queries before the first row, the
+        last sample for queries past the last row, and a clamped linear
+        interpolation in between. Returns ``0.0`` when the model has no
+        samples at all.
+
+        Args:
+            ts: Query timestamp (will be offset by ``_offset``).
+            values: Per-sample list of latencies (in seconds) sorted in
+                the same order as ``_ts``.
+
+        Returns:
+            float: Interpolated latency in seconds.
+        """
+        if not self._ts:
+            return 0.0
+        lookup_ts = float(ts) + self._offset
+        idx = bisect.bisect_left(self._ts, lookup_ts)
+        if idx <= 0:
+            return values[0]
+        if idx >= len(self._ts):
+            return values[-1]
+        left_ts = self._ts[idx - 1]
+        right_ts = self._ts[idx]
+        left_val = values[idx - 1]
+        right_val = values[idx]
+        if right_ts == left_ts:
+            return right_val
+        ratio = (lookup_ts - left_ts) / (right_ts - left_ts)
+        return left_val + (right_val - left_val) * ratio
+
+    def feed_latency(self, exch_ts, symbol):
+        """Return the interpolated feed latency for ``exch_ts``."""
+        _ = symbol
+        return self._interp(exch_ts, self._feed)
+
+    def order_entry_latency(self, local_ts, symbol):
+        """Return the interpolated order-entry latency for ``local_ts``."""
+        _ = symbol
+        return self._interp(local_ts, self._entry)
+
+    def order_response_latency(self, exch_ts, symbol):
+        """Return the interpolated order-response latency for ``exch_ts``."""
+        _ = symbol
+        return self._interp(exch_ts, self._resp)
+
+
+class LatencyEngine:
+    """Drives the per-stage latencies for orders and events.
+
+    Holds the priority queue of in-flight orders (sorted by the time at
+    which they should become visible to the exchange) and the set of
+    order ids that have been cancelled before they became visible. When
+    no latency model is supplied, the engine degenerates to a pass-through
+    that returns events and orders without applying any delay.
+    """
+
+    def __init__(self, latency_model=None):
+        """Initialize the latency engine.
+
+        Args:
+            latency_model: Optional :class:`LatencyModel` used to compute
+                per-stage delays. ``None`` disables all delays.
+        """
+        self._model = latency_model
+        self._pending_orders = []
+        self._cancelled_order_ids = set()
+        self._seq = 0
+
+    def delay_order(self, order, submit_ts, symbol):
+        """Park an order in the visibility queue based on entry latency.
+
+        Args:
+            order: The order that was just submitted locally.
+            submit_ts: Local timestamp of the submission.
+            symbol: Symbol the order is for.
+
+        Returns:
+            float | None: The exchange-visible timestamp the order will
+            become visible at, or ``None`` if latency is disabled
+            (``latency_model is None``) or the computed delay is
+            non-positive.
+        """
+        if self._model is None:
+            return None
+        visible_ts = float(submit_ts) + float(self._model.order_entry_latency(submit_ts, symbol))
+        if visible_ts <= float(submit_ts):
+            return None
+        heapq.heappush(self._pending_orders, (visible_ts, self._seq, order, symbol))
+        self._seq += 1
+        return visible_ts
+
+    def cancel_order(self, order):
+        """Mark an in-flight order as cancelled.
+
+        Cancelled orders are removed from the pending queue the next time
+        they would have become visible, so the matching engine never sees
+        them.
+
+        Args:
+            order: The order to cancel (identified by ``id(order)``).
+        """
+        self._cancelled_order_ids.add(id(order))
+
+    def get_visible_orders(self, current_ts):
+        """Pop and return all orders whose visibility time has been reached.
+
+        The order heap is sorted by ``(visible_ts, sequence)``, so equal
+        timestamps are popped in submission order. Any order whose id was
+        previously passed to :meth:`cancel_order` is discarded and its id
+        is removed from the cancelled set.
+
+        Args:
+            current_ts: Current local time used to determine which orders
+                have become visible.
+
+        Returns:
+            list[tuple]: ``(order, symbol)`` tuples for the orders that
+            should be released to the matching engine.
+        """
+        visible = []
+        now = float(current_ts)
+        while self._pending_orders and self._pending_orders[0][0] <= now:
+            _, _, order, symbol = heapq.heappop(self._pending_orders)
+            if id(order) in self._cancelled_order_ids:
+                self._cancelled_order_ids.discard(id(order))
+                continue
+            visible.append((order, symbol))
+        return visible
+
+    def apply_feed_latency(self, event):
+        """Set ``local_time`` on ``event`` after applying feed latency.
+
+        The event is mutated in place by setting a ``local_time`` attribute
+        equal to the exchange timestamp plus the model's feed latency. If no
+        model is configured, a valid receive timestamp already supplied by a
+        live feed is preserved; otherwise ``local_time`` falls back to the
+        event's exchange timestamp.
+
+        Args:
+            event: The market-data event to adjust. Must expose
+                ``timestamp`` and (optionally) ``symbol``.
+
+        Returns:
+            object: The same event object, for convenient chaining.
+        """
+        if self._model is None:
+            local_time = getattr(event, "local_time", None)
+            if (
+                isinstance(local_time, (int, float))
+                and not isinstance(local_time, bool)
+                and math.isfinite(local_time)
+                and local_time > 0
+            ):
+                return event
+            setattr(event, "local_time", getattr(event, "timestamp", 0.0))
+            return event
+        exch_ts = getattr(event, "timestamp", 0.0)
+        symbol = getattr(event, "symbol", "")
+        setattr(event, "local_time", exch_ts + float(self._model.feed_latency(exch_ts, symbol)))
+        return event
+
+    def get_response_time(self, exch_ts, symbol):
+        """Return the local time at which an exchange ack is received.
+
+        Args:
+            exch_ts: Exchange-side timestamp of the acknowledgement.
+            symbol: Symbol the response is for.
+
+        Returns:
+            float: ``exch_ts`` plus the model's order-response latency, or
+            ``exch_ts`` itself when no model is configured.
+        """
+        if self._model is None:
+            return float(exch_ts)
+        return float(exch_ts) + float(self._model.order_response_latency(exch_ts, symbol))