Struct RequestOpen 

pub struct RequestOpen {
    pub side: Side,
    pub price: Option<Decimal>,
    pub quantity: Decimal,
    pub kind: OrderKind,
    pub time_in_force: TimeInForce,
    pub position_id: Option<PositionId>,
    pub reduce_only: bool,
    pub market: Option<MarketSnapshot>,
}

Parameters for opening a new order.

Warning: reduce_only Default Behavior

The reduce_only field defaults to false, which means:

• A Sell order defaults to SellToOpen (open short / write option)
• A Buy order defaults to BuyToOpen (open long)

For closing positions, callers MUST explicitly set reduce_only: true. Failure to do so on non-crypto instruments (equities, options) will:

• On non-margin accounts: result in a 422 rejection from the exchange
• On margin accounts: silently open a short position instead of closing the long

The close_open_positions_with_market_orders helper sets this correctly. Direct RequestOpen construction must handle it manually.

Fields

side: Side

price: Option<Decimal>

Limit price for the order. Required for Limit/StopLimit orders, and for TrailingStopFixedLimit orders, whose limit stays fixed while the trigger trails. None for Market/Stop/TrailingStop orders (which execute at market price when triggered), and for TrailingStopLimit orders, whose limit price follows from their stop and limit_offset.

quantity: Decimal

kind: OrderKind

time_in_force: TimeInForce

position_id: Option<PositionId>

Target PositionId for this order in OmsMode::Hedging.

For opening orders: the position this fill should open or add to. For closing orders: the position this fill should reduce or close. In OmsMode::Netting, leave as None (ignored).

reduce_only: bool

Constrain this order to only reduce existing positions, never open new ones.

Used by exchanges that require explicit open/close intent (Alpaca, Interactive Brokers, Schwab). Adapters derive venue-specific semantics from this flag + side:

• reduce_only=false, Buy → BuyToOpen (open long / add to long)
• reduce_only=false, Sell → SellToOpen (open short / write option)
• reduce_only=true, Buy → BuyToClose (close short)
• reduce_only=true, Sell → SellToClose (close long)

Exchanges that infer intent from positions (Binance, Deribit) may map this to their reduceOnly parameter or ignore it entirely.

market: Option<MarketSnapshot>

Market state observed at the instant this request was created, if any was sampled.

This is decision-time provenance, not an instruction to the venue. It records what the sender was looking at when it chose to trade, which is the one price a fill can be measured against after the fact — implementation shortfall is the difference between this and the price actually obtained.

Live venues must ignore this field

No live exchange adapter reads it and none should: a venue prices a fill from its own book, and an adapter that forwarded these prices would be sending the client’s view of the market back as an instruction. Every adapter in this crate leaves it untouched.

A simulated venue fills from it only when it has no book of its own

SimulatedVenue reads this only in VenueRegime::RequestPriced, where it has no market feed and this snapshot is its only price source. That is the regime MockExecution and MockExchange use: the request’s snapshot is priced through the venue’s FillModel, and without it a market order carries no price at all — price is None by construction for OrderKind::Market — so the venue can only reject.

A MarketDriven venue ignores it and prices from its own book, like a live one. This field is then decision-time provenance alone, and the difference between it and the price obtained is implementation shortfall.

Sampling it at creation rather than at fill time is deliberate. It is the one instant with a well-defined position on a simulated timeline for the sender: everything the sender had seen by then is in it, and nothing it had not seen can be. What makes it safe for a venue to hold a book instead is that its driver paces the feed — routing each market event to the venue before the client that reacts to it sees the same event, and booking each request at the instant it arrives. A venue that sampled a stream it shares with the engine but does not pace could fill against prices from arbitrarily far in the future, which is why the regime is a property of how the venue is driven rather than a configuration flag.

None versus an empty snapshot

None means no snapshot was taken — a live path, or a caller that constructed the request directly. Some holding a MarketSnapshot::is_empty snapshot means one was taken and the instrument had no price yet, which is what a cold start looks like. A RequestPriced simulated venue distinguishes the two in its rejection, because the fixes differ.

#[serde(default)] so requests serialised before this field existed still load.

Trait Implementations

impl Clone for RequestOpen

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RequestOpen

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RequestOpen

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RequestOpen

impl Hash for RequestOpen

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for RequestOpen

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for RequestOpen

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for RequestOpen

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for RequestOpen

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RequestOpen