Struct RequestOpen 

#[non_exhaustive]
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: ReduceOnly,
    pub market: Option<MarketSnapshot>,
    pub margin_effect: Option<MarginEffect>,
}

Parameters for opening a new order.

Warning: reduce_only Default Behavior

The reduce_only field defaults to ReduceOnly::No, 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 to ReduceOnly::Position (or ReduceOnly::PositionAndFreeBase). 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. A caller building its own closing request must set it with with_reduce_only.

#[non_exhaustive], so a field can be added without breaking a caller. Outside this crate, build one with RequestOpen::new and the with_* methods, and change a copy by assigning its public fields.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

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. A price given with a Market order anyway is ignored, by the simulated venue and by the live clients that accept market orders.

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: ReduceOnly

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

Used by exchanges that require explicit open/close intent (Alpaca, Interactive Brokers, Schwab). Adapters derive venue-specific semantics from ReduceOnly::is_reduce_only + side, so both reduce-only values map alike:

• not reduce-only, Buy → BuyToOpen (open long / add to long)
• not reduce-only, Sell → SellToOpen (open short / write option)
• reduce-only, Buy → BuyToClose (close short)
• reduce-only, Sell → SellToClose (close long)

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

The rustrade engine enforces it on fills, whatever the venue did with it: a fill of a reduce-only order never grows or flips the engine’s position. A fill larger than the opposite position is cut so the position lands flat, and the excess is reported rather than applied. See Trade::holding_move.

#[serde(default)] so requests serialised before this field existed still load, and a true or false serialised before it was a ReduceOnly loads as ReduceOnly::Position or ReduceOnly::No.

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 has no limit price to fall back on — the venue ignores price on an 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.

margin_effect: Option<MarginEffect>

What this order does to a margin account’s loans, or None to take the client’s default.

Only a margin client or a simulated venue with spot margin acts on a borrow or a repay; see MarginEffect for the three values. A client that cannot honour a Some refuses the order unsent with OrderError::UnsupportedMarginEffect: a cash or spot-only account takes Some(NoSideEffect) alone, and a client that cannot promise it (account-level margin, or implicit borrowing as under Hyperliquid’s portfolio margin) takes no Some at all, NoSideEffect included. A caller that sets an effect on every order must leave it None for those venues.

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

Implementations

impl RequestOpen

pub fn new( side: Side, price: Option<Decimal>, quantity: Decimal, kind: OrderKind, time_in_force: TimeInForce, ) -> Self

A request with no position_id, not reduce_only, and no market snapshot. Set those with the with_* methods.

pub fn with_position_id(self, position_id: PositionId) -> Self

This request with the position_id it targets in OmsMode::Hedging.

pub fn with_reduce_only(self, reduce_only: ReduceOnly) -> Self

This request with its reduce_only set to reduce_only.

pub fn with_market(self, market: MarketSnapshot) -> Self

This request with the market its sender observed when it created it.

pub fn with_margin_effect(self, margin_effect: MarginEffect) -> Self

This request with its margin_effect set to margin_effect, instead of the client’s default.

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