Enum StaleMarketPolicy 

#[non_exhaustive]
pub enum StaleMarketPolicy {
    Off,
    Wait {
        max_age: Duration,
    },
}

What a simulated venue does with a market order when the instrument’s market is stale, as MockExecutionConfig::stale_market selects. Defaults to Off.

The problem it addresses

A venue fed a market keeps the last one it saw for each instrument, and by default fills a market order against it however old it is. On a bar feed, a market order on an instrument with no bar at the current instant therefore fills at the close of its last bar, which may be minutes, hours or a weekend old. A real order would not get that price: in a quiet market it trades against the book, and in an outage, a halt or a closed market it is refused or waits for the reopen, filling at a price that may have gapped. A bar that only carries the previous close forward, with zero volume, makes this worse: it looks recent, but nothing traded.

A venue cannot tell a quiet market from a dead feed or a halt by looking at bars, and this policy does not try to. It treats an old market as one nobody can trade in yet.

When to turn it on, and why it is off by default

Turn it on for bar feeds, with a max_age a little over the bar interval, so that only a market with a missing bar counts as stale. It stays off by default because a venue cannot know a feed’s bar interval, and because on a quote or tick feed the book stays valid until it is replaced: a quiet book is still a book a market order can trade against.

#[non_exhaustive]: other actions on a stale market may be added.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Off

Fill a market order against the market the venue holds, however old.

Wait

A market order arriving when the instrument’s last fresh observation is more than max_age old waits for the next one.

What is fresh

An observation the driver marks fresh: a trade, a quote, or a bar something traded in. A bar reported with zero volume still moves the price the venue holds, but not the instant the market’s age is measured from. An observation exactly max_age old is still fresh, so a max_age of zero accepts an order only at the instant of a fresh observation.

An instrument whose venue has no price at all is not stale but unpriced, and its market orders are rejected as they are without this policy.

What waits

Market orders only. The order is accepted as Open and held as MarketOrderTiming::NextBar holds one: the venue holds what it would cost at the current price, a cancel takes it back, and an order the account cannot cover at that price is refused on arrival. An immediate-or-cancel or fill-or-kill market order is rejected instead, with a reason naming this policy: it asked to trade now or not at all. That includes the immediate-or-cancel orders an engine sends to close positions, so a strategy closing out on a stale instrument has to try again once its market is fresh.

A limit order that is marketable on arrival is not covered: it still fills against the market the venue holds, however old.

When it fills

On the instrument’s next fresh observation, as if it had arrived just after it: priced by the venue’s FillModel from the market that observation leaves, moved by its slippage, and costed afresh, as any taker fill is. That is a trade’s or quote’s price, or a bar’s close. The fill is stamped at the observation’s instant and follows the fills of orders already resting, which the observation crossed first. An order the account can no longer afford, or that the market cannot price, is cancelled and reported.

Only an observation of that instrument releases a held order: a clock moving, or a fresh observation of another instrument, never does. A deadline the order carries still retires it, and an order still waiting when its driver runs out of data is retired as expired, filled nothing.

With MarketOrderTiming::NextBar

Every market order already waits for its instrument’s next bar and fills at that bar’s price, so a fresh market changes nothing. A bar reported with zero volume releases nothing: the orders held for it wait for the next bar something traded in, except an immediate-or-cancel or fill-or-kill order, which the bar cancels, since it had nothing to trade. An immediate-or-cancel or fill-or-kill order arriving on a stale market is rejected, as above.

Needs a market feed

A RequestPriced venue, the kind MockExchange drives, has no market feed to measure an age from, so it rejects every market order, naming this policy. On a venue that is fed a market, an instrument it has never been fed has no price at all, and its market orders are rejected as unpriced, as above.

Serialised

max_age is a Duration, so it serialises as seconds and nanoseconds: {"Wait":{"max_age":{"secs":90,"nanos":0}}}.

Fields

max_age: Duration

How old the last fresh observation may be for a market order to fill on arrival.

Trait Implementations

impl Clone for StaleMarketPolicy

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StaleMarketPolicy

impl Debug for StaleMarketPolicy

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

Formats the value using the given formatter.

impl Default for StaleMarketPolicy

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for StaleMarketPolicy

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StaleMarketPolicy

impl Hash for StaleMarketPolicy

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 StaleMarketPolicy

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 StaleMarketPolicy

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for StaleMarketPolicy

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 StaleMarketPolicy

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 StaleMarketPolicy