Struct MockExchange 

pub struct MockExchange {
    pub venue: SimulatedVenue,
    pub latency_ms: u64,
    pub request_rx: UnboundedReceiver<MockExchangeRequest>,
    pub event_tx: Sender<UnindexedAccountEvent>,
    /* private fields */
}

Asynchronous driver for a SimulatedVenue: channels, simulated latency, emission ordering.

It owns no ledger and prices nothing. What the venue models, what it rejects and what it leaves unaccounted for are documented on SimulatedVenue; this type decides only when the venue’s output reaches a client.

It drives a venue in one of two VenueRegimes:

• new: request-priced, for a backtest that sends one request at a time. A market order is priced from the snapshot its request carries, and nothing can rest.
• new_market_driven: fed a live market, for paper trading. Limit orders rest and fill as the market crosses them, as in a backtest of the same venue.

Ordering

Everything the venue produces — account events and every response, fetches included — is queued in the order the venue produced it and drained by a single task, so emission order equals booking order. A response is emitted after the account events produced before it, so a client holding a response has already been sent every event the venue booked ahead of it. Closing request_rx closes that queue in turn, and run returns only once it has drained.

Fields

venue: SimulatedVenue

The venue’s state machine. Ledger, pricing and ordering obligations live here.

latency_ms: u64

Simulated round-trip delay. Transport policy, so it lives on the driver, not the venue.

request_rx: UnboundedReceiver<MockExchangeRequest>

event_tx: Sender<UnindexedAccountEvent>

Implementations

impl MockExchange

pub fn new( config: MockExecutionConfig, request_rx: UnboundedReceiver<MockExchangeRequest>, event_tx: Sender<UnindexedAccountEvent>, instruments: FnvHashMap<InstrumentNameExchange, Instrument<ExchangeId, AssetNameExchange>>, ) -> Self

A request-priced driver, building its venue from config with SimulatedVenue::new.

Each request is booked when it is received, at its own time_request plus half of latency_ms, and its output is emitted latency_ms of real time later.

pub fn new_market_driven( venue: SimulatedVenue, latency_ms: u64, request_rx: UnboundedReceiver<MockExchangeRequest>, event_tx: Sender<UnindexedAccountEvent>, feed: BoxStream<'static, MarketFeedEvent>, clock: MockExchangeClock, ) -> Self

A driver that runs venue on a live market: feed supplies the market, and clock the time everything is stamped with.

Time

The venue is stamped from clock, held so that it never moves backwards: an instant before the latest one already stamped is stamped with that latest one instead. A request’s own time_request is not used. The clock is moved to clock’s instant when run starts, so interest and holding costs accrue from then, and on each venue deadline (an order’s expiry, a holding-cost or interest boundary) when it falls, whether or not anything else arrives.

Latency, as in a backtest of the same venue

A request waits half of latency_ms of real time before it is booked, against the market held at that moment, and its output is emitted half of latency_ms after that. A fill the market causes on a resting order pays the second half alone. Integer division drops an odd millisecond from each half.

Market input

Each MarketFeedEvent::Observation is applied with SimulatedVenue::apply_market as it arrives, ahead of a request that is due at the same moment. An instrument the feed has not yet observed refuses a market order, while a limit order on it rests.

When the feed reports MarketFeedEvent::Lagged, the driver logs an error and emits a StreamTerminated after everything queued before it, which ends the account stream of a MockExecution client. The venue keeps running, and nothing it booked is lost: a client that reopens the stream can read its fills back. What the dropped observations showed is lost, so a resting order may have missed a fill. Fill recovery cannot repair that.

When the feed ends, the driver logs a warning and serves requests on the last market it saw. Deadlines keep falling.

The feed is served ahead of requests, so while it has a backlog a request is read, and its wait for the venue begins, only after that backlog is applied. The latency above is a lower bound. The backlog is bounded by the feed’s own buffer.

Panics

If venue is not VenueRegime::MarketDriven: a request-priced venue does not price from the feed, so feeding it would change nothing.

pub async fn run(self)

Serves requests until the request channel closes, then lets queued output finish.

Venue output is not emitted inline: it is queued and drained by a single task, so that emission order equals booking order. Closing the request channel closes that queue in turn, and this method returns only once the queue has drained, so shutting the venue down cannot strand a fill the client is still waiting on. A market-driven driver first books the requests still waiting out their latency.

pub fn account_stream(&self) -> BoxStream<'static, UnindexedAccountEvent>

Trait Implementations

impl Debug for MockExchange

Manual because the market feed is a boxed stream, which has no Debug.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.