Struct SimulatedExchange 

pub struct SimulatedExchange {
    pub id: Venue,
    pub oms_type: OmsType,
    pub account_type: AccountType,
    pub base_currency: Option<Currency>,
    /* private fields */
}

Simulated exchange venue for realistic trading execution during backtesting.

The SimulatedExchange provides a simulation of a trading venue, including order matching engines, account management, and realistic execution models. It maintains order books, processes market data, and executes trades with configurable latency and fill models to accurately simulate real market conditions during backtesting.

Key features:

• Multi-instrument order matching with realistic execution
• Configurable fee, fill, and latency models
• Support for various order types and execution options
• Account balance and position management
• Market data processing and order book maintenance
• Simulation modules for custom venue behaviors

Fields

id: Venue

The venue identifier.

oms_type: OmsType

The order management system type.

account_type: AccountType

The account type for the venue.

base_currency: Option<Currency>

The optional base currency for single-currency accounts.

Implementations

impl SimulatedExchange

pub fn new( config: SimulatedVenueConfig, cache: Rc<RefCell<Cache>>, clock: Rc<RefCell<dyn Clock>>, ) -> Result<Self>

Creates a new SimulatedExchange instance from a venue configuration.

Errors

Returns an error if:

• starting_balances is empty.
• base_currency is Some but starting_balances contains multiple currencies.

pub fn register_client(&mut self, client: Rc<dyn ExecutionClient>)

Registers the execution client for the exchange.

pub fn set_fill_model(&mut self, fill_model: FillModelAny)

Sets the fill model for the exchange.

pub fn set_latency_model(&mut self, latency_model: Box<dyn LatencyModel>)

Sets the latency model for the exchange.

pub fn set_settlement_price( &mut self, instrument_id: InstrumentId, price: Price, )

Sets the settlement price for the given instrument.

pub const fn book_type(&self) -> BookType

Returns the configured book type for this venue.

pub fn instrument_ids(&self) -> impl Iterator<Item = &InstrumentId>

Returns an iterator over the instrument IDs registered with this exchange.

pub fn initialize_account(&mut self)

pub fn load_open_orders(&mut self)

Loads non-emulated open orders from the cache into matching engines.

pub fn add_instrument(&mut self, instrument: InstrumentAny) -> Result<()>

Adds an instrument to the simulated exchange and initializes its matching engine.

Errors

Returns an error if the exchange account type is Cash and the instrument is a CryptoPerpetual or CryptoFuture.

Panics

Panics if the instrument cannot be added to the exchange.

pub fn best_bid_price(&self, instrument_id: InstrumentId) -> Option<Price>

Returns the best bid price for the given instrument, if available.

pub fn best_ask_price(&self, instrument_id: InstrumentId) -> Option<Price>

Returns the best ask price for the given instrument, if available.

pub fn get_book(&self, instrument_id: InstrumentId) -> Option<&OrderBook>

Returns a reference to the order book for the given instrument, if available.

pub fn get_matching_engine( &self, instrument_id: &InstrumentId, ) -> Option<&OrderMatchingEngine>

Returns a reference to the matching engine for the given instrument, if available.

pub const fn get_matching_engines( &self, ) -> &AHashMap<InstrumentId, OrderMatchingEngine>

Returns a reference to all matching engines keyed by instrument ID.

pub fn get_books(&self) -> AHashMap<InstrumentId, OrderBook>

Returns all order books keyed by instrument ID.

pub fn get_open_orders( &self, instrument_id: Option<InstrumentId>, ) -> Vec<OrderMatchInfo>

Returns all open orders, optionally filtered by instrument ID.

pub fn get_open_bid_orders( &self, instrument_id: Option<InstrumentId>, ) -> Vec<OrderMatchInfo>

Returns all open bid orders, optionally filtered by instrument ID.

pub fn get_open_ask_orders( &self, instrument_id: Option<InstrumentId>, ) -> Vec<OrderMatchInfo>

Returns all open ask orders, optionally filtered by instrument ID.

pub fn get_account(&self) -> Option<AccountAny>

Returns the account for this exchange, if an execution client is registered.

pub fn cache(&self) -> &Rc<RefCell<Cache>>

Returns a reference to the cache.

pub fn adjust_account(&mut self, adjustment: Money)

Adjusts the account balance by the given amount.

Panics

Panics if generating account state fails during adjustment.

pub fn has_pending_commands(&self, ts_now: UnixNanos) -> bool

Returns whether there are pending commands at or before ts_now.

pub fn iterate_matching_engines(&mut self, ts_now: UnixNanos)

Iterates all matching engines so newly submitted orders can match against the current market state.

pub fn set_clock_time(&self, ts_now: UnixNanos)

Advances the exchange clock to the given timestamp so that any event generators (modules, account state) see the correct time even when no commands are pending.

Panics

Panics if the clock is not a [TestClock].

pub fn send(&mut self, command: TradingCommand)

Sends a trading command to the exchange for processing.

pub fn process_order_book_delta(&mut self, delta: OrderBookDelta)

Processes a single order book delta.

Panics

Panics if adding a missing instrument during delta processing fails.

pub fn process_order_book_deltas(&mut self, deltas: &OrderBookDeltas)

Processes a batch of order book deltas.

Panics

Panics if adding a missing instrument during deltas processing fails.

pub fn process_order_book_depth10(&mut self, depth: &OrderBookDepth10)

Processes an L2 order book depth snapshot.

Panics

Panics if adding a missing instrument during depth10 processing fails.

pub fn process_quote_tick(&mut self, quote: &QuoteTick)

Processes a quote tick and updates the matching engine.

Panics

Panics if adding a missing instrument during quote tick processing fails.

pub fn process_trade_tick(&mut self, trade: &TradeTick)

Processes a trade tick and updates the matching engine.

Panics

Panics if adding a missing instrument during trade tick processing fails.

pub fn process_bar(&mut self, bar: Bar)

Processes a bar and updates the matching engine.

Panics

Panics if adding a missing instrument during bar processing fails.

pub fn process_instrument_status(&mut self, status: InstrumentStatus)

Processes an instrument status update.

Panics

Panics if adding a missing instrument during instrument status processing fails.

pub fn process_instrument_close(&mut self, close: InstrumentClose)

Processes an instrument close event.

Panics

Panics if adding a missing instrument during instrument close processing fails.

pub fn process(&mut self, ts_now: UnixNanos)

Processes all pending inflight and queued trading commands up to ts_now.

Panics

Panics if popping an inflight command fails during processing.

pub fn process_modules(&mut self, ts_now: UnixNanos)

Runs all simulation modules for the given timestamp.

Must be called once per time step after all command queues have fully settled, not inside the settle loop.

pub fn reset(&mut self)

Resets the exchange to its initial state.

pub fn log_diagnostics(&self)

Logs diagnostic information from all simulation modules.

Trait Implementations

impl Debug for SimulatedExchange

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

Formats the value using the given formatter.