Struct MockExchange 

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

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.

Ordering

A filled open’s account events and its response are queued together and drained by a single task, so emission order equals booking order across fills, not merely within one. Closing request_rx closes that queue in turn, and run returns only once it has drained.

⚠️ Known limitation: fetch responses are not ordered against anything

Only opens go through that queue. Every Fetch* response is sent from a task of its own, so two fetches issued together may be answered in either order, and a fetch issued after an open may be answered before it. A client that reads a balance through FetchBalances while fills are in flight can therefore observe one that is newer or older than the BalanceSnapshot it is about to receive. Fills themselves are unaffected, and a backtest driving this venue request-at-a-time never observes it; paper trading against a live feed can.

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

pub async fn run(self)

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

Filled opens are not emitted inline: they are queued and drained by a single task, so that emission order equals booking order across fills, not merely within one. 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.

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

Trait Implementations

impl Debug for MockExchange

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

Formats the value using the given formatter.