Struct InstrumentAccountSnapshot 

pub struct InstrumentAccountSnapshot<ExchangeKey = ExchangeIndex, AssetKey = AssetIndex, InstrumentKey = InstrumentIndex> {
    pub instrument: InstrumentKey,
    pub orders: Vec<OrderSnapshot<ExchangeKey, AssetKey, InstrumentKey>>,
    pub orders_complete: bool,
    pub position: PositionReport,
    pub isolated: Option<IsolatedInstrumentState<AssetKey>>,
}

One instrument’s slice of an AccountSnapshot: its orders, and its position or isolated balances where the venue has them.

Fields

instrument: InstrumentKey

orders: Vec<OrderSnapshot<ExchangeKey, AssetKey, InstrumentKey>>

Orders the venue reported for this instrument, keyed by the ClientOrderId the order was placed with where the venue reports it.

Whether this is every order open at the venue is stated by orders_complete, not implied by the list.

orders_complete: bool

true only when orders lists every order open at the venue for this instrument when it was read, each under the ClientOrderId it was placed with.

A consumer may then read an order’s absence as “no longer open”: it filled, was cancelled or expired. The engine does exactly that, retiring a tracked order a complete list omits. A wrong true therefore retires live orders, so a client sets it only when nothing can be missing:

• the read covered every open order, with no page cap or partial result;
• no open order was dropped on conversion;
• each order carries the id it was placed with, so a tracked order can be found in it.

false claims nothing about absent orders, and is the default for a snapshot that does not say.

position: PositionReport

The venue’s position in this instrument, for any instrument whose holding the venue tracks separately from cash balances: perpetuals, futures, options, and equities (e.g. Alpaca).

PositionReport::Unreported when the venue does not report positions, for holdings reported as asset balances instead, such as spot crypto, and when the read could not establish the position. PositionReport::Flat is a claim that the venue holds none, so a client reports it only when it read every position the venue has for the instrument. See each client’s account_snapshot for what it reports.

A client that reports positions lists each instrument it was asked for whose position it can establish, flat ones included. An instrument it leaves out, like one it reports as Unreported, is unknown, never flat: a client can be unable to establish a position (see its account_snapshot). Asked for all instruments (an empty list), it may list only those with something to report.

isolated: Option<IsolatedInstrumentState<AssetKey>>

Per-pair isolated-margin balances and risk, for venues with isolated sub-accounts (e.g. Binance isolated margin). None for cross margin, spot, and all other contexts.

Surfaced here — attached to the instrument — rather than folded into the asset-keyed AccountSnapshot::balances because isolated sub-accounts are per-(pair, asset): the same asset (e.g. USDT) in two isolated pairs is a separate pool, which the asset-keyed balance model cannot represent without collision. The engine does not store this; a consumer reads it off the snapshot to compose per-pair risk. See IsolatedInstrumentState.

Implementations

impl<ExchangeKey, AssetKey, InstrumentKey> InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

pub const fn new( instrument: InstrumentKey, orders: Vec<OrderSnapshot<ExchangeKey, AssetKey, InstrumentKey>>, orders_complete: bool, position: PositionReport, isolated: Option<IsolatedInstrumentState<AssetKey>>, ) -> InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

Trait Implementations

impl<ExchangeKey: Clone, AssetKey: Clone, InstrumentKey: Clone> Clone for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<ExchangeKey: Debug, AssetKey: Debug, InstrumentKey: Debug> Debug for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

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

Formats the value using the given formatter.

impl<'de, ExchangeKey, AssetKey, InstrumentKey> Deserialize<'de> for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

where ExchangeKey: Deserialize<'de>, AssetKey: Deserialize<'de>, InstrumentKey: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<ExchangeKey: Eq, AssetKey: Eq, InstrumentKey: Eq> Eq for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

impl<ExchangeKey: Hash, AssetKey: Hash, InstrumentKey: Hash> Hash for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

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<ExchangeKey: Ord, AssetKey: Ord, InstrumentKey: Ord> Ord for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

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<ExchangeKey: PartialEq, AssetKey: PartialEq, InstrumentKey: PartialEq> PartialEq for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

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

Equality operator ==.

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

Inequality operator !=.

impl<ExchangeKey: PartialOrd, AssetKey: PartialOrd, InstrumentKey: PartialOrd> PartialOrd for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

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<ExchangeKey, AssetKey, InstrumentKey> Serialize for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>

where ExchangeKey: Serialize, AssetKey: Serialize, InstrumentKey: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<ExchangeKey: PartialEq, AssetKey: PartialEq, InstrumentKey: PartialEq> StructuralPartialEq for InstrumentAccountSnapshot<ExchangeKey, AssetKey, InstrumentKey>