Struct Trade 

#[non_exhaustive]
pub struct Trade<AssetKey, InstrumentKey> {

    pub id: TradeId,
    pub order_id: OrderId,
    pub instrument: InstrumentKey,
    pub strategy: StrategyId,
    pub time_exchange: DateTime<Utc>,
    pub side: Side,
    pub price: Decimal,
    pub quantity: Decimal,
    pub order_filled_quantity: Option<Decimal>,
    pub fees: AssetFees<AssetKey>,
    pub origin: TradeOrigin,
    pub position_side: Option<Side>,
    pub client_order_id: Option<ClientOrderId>,
}

One execution: a fill the venue reported, or one the engine settled itself.

#[non_exhaustive], so a field can be added without breaking a caller. Outside this crate, build one with Trade::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.

id: TradeId

order_id: OrderId

instrument: InstrumentKey

strategy: StrategyId

time_exchange: DateTime<Utc>

side: Side

price: Decimal

quantity: Decimal

The size of this execution.

order_filled_quantity: Option<Decimal>

The order’s cumulative filled quantity as of this execution, as the venue reported it – not the size of this execution, which is Trade::quantity.

A fill carries two facts: that an execution happened, and what it left the order at. A consumer that tracks order state needs both, and they arrive together or not at all. Where the venue supplies the second, carrying it here lets the order be advanced from the fill itself rather than from a separate message that may never come.

Advancing from a cumulative is idempotent: re-applying the same fill, or applying two out of order, cannot double-count, because the receiver takes the greater of what it holds and what is reported rather than adding to a running total.

None means the venue’s fill payload does not carry it, and the order’s state must be learned some other way – an order snapshot, or a reconciliation fetch. It is not a claim that nothing is filled. Known producers, as of writing:

Source	Reports it
Binance Spot / Margin WebSocket executionReport	yes (z)
Binance Spot / Margin fill recovery after a disconnect	yes, rebuilt from the order’s executions; None where that lookup failed or ran out of time
Binance Spot / Margin fetch_trades (myTrades REST)	no
Alpaca WebSocket trade_updates	yes (order.filled_qty)
Alpaca account-activities REST	yes (cum_qty)
Interactive Brokers ExecutionData	yes (cumulative_quantity)
Hyperliquid userFills	no
SimulatedVenue	yes

#[serde(default)] so trades serialised before this field existed still deserialise, as None.

fees: AssetFees<AssetKey>

origin: TradeOrigin

Why the fill happened, as far as its producer can tell. See TradeOrigin for what each venue reports.

#[serde(default)] so trades serialised before this field existed still deserialise, as TradeOrigin::Order.

position_side: Option<Side>

The side of the position the fill applies to, when the venue names one: Side::Buy for a long, Side::Sell for a short.

A venue in hedge mode, holding a long and a short in one instrument at once, names the position each fill belongs to (Binance USD-M futures’ LONG and SHORT). The engine in OmsMode::Hedging checks a forced fill, which matches none of its orders, against it: a forced fill must reduce the position the venue names. It only ever confirms the side a reducing fill already implies, the side opposite its own, and does not choose among several of the engine’s positions on that side.

It takes part in the derived Eq, Hash and Ord, as every field does: deduplicate fills by instrument and id, not by the whole Trade. None when the venue names none, as every client in this crate does as of writing: none trades a venue in hedge mode.

#[serde(default)] so trades serialised before this field existed still deserialise, as None.

client_order_id: Option<ClientOrderId>

The client order id of the order this fill belongs to, as the venue reported it with the fill.

The id is chosen before the order is sent, so a consumer can attribute a fill by it at once. That includes a fill of an order placed outside the engine on the same account, which no order the engine knows matches: order_id is the venue’s, and the fill can arrive before the venue’s response to the order names it, or long after, in a recovery read. A consumer that trades an account outside the engine can mark those orders’ client order ids, by a prefix say, and keep their fills from the engine.

None means the fill’s payload did not carry one. It is not a claim that the order has none. Known producers, as of writing:

Source	Reports it
Binance Spot / Margin WebSocket executionReport	yes (c)
Binance Spot / Margin fill recovery after a disconnect	yes, read from each recovered fill’s order; None where that lookup failed or ran out of time
Binance Spot / Margin fetch_trades (myTrades REST)	no
Alpaca WebSocket trade_updates	yes (order.client_order_id)
Alpaca account-activities REST (fill recovery, fetch_trades), fetch_option_events	no
Interactive Brokers executions	yes, the order reference, which this crate’s client sets to the client order id; None for an order without one
Hyperliquid userFills	yes, the client order id the order’s cloid maps to; None for an order placed without a cloid
SimulatedVenue	yes
The rustrade engine’s expiry settlement	no

#[serde(default)] so trades serialised before this field existed still deserialise, as None.

Implementations

impl<AssetKey, InstrumentKey> Trade<AssetKey, InstrumentKey>

pub fn new( id: TradeId, order_id: OrderId, instrument: InstrumentKey, strategy: StrategyId, time_exchange: DateTime<Utc>, side: Side, price: Decimal, quantity: Decimal, order_filled_quantity: Option<Decimal>, fees: AssetFees<AssetKey>, ) -> Self

A trade of TradeOrigin::Order. Set another origin with with_origin.

pub fn with_origin(self, origin: TradeOrigin) -> Self

This trade with its origin set.

pub fn with_position_side(self, position_side: Side) -> Self

This trade with the position_side the venue named.

pub fn with_client_order_id(self, client_order_id: ClientOrderId) -> Self

This trade with the client_order_id the venue reported.

pub fn value_quote(&self) -> Decimal

Trait Implementations

impl<AssetKey: Clone, InstrumentKey: Clone> Clone for Trade<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<AssetKey: Debug, InstrumentKey: Debug> Debug for Trade<AssetKey, InstrumentKey>

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

Formats the value using the given formatter.

impl<'de, AssetKey, InstrumentKey> Deserialize<'de> for Trade<AssetKey, InstrumentKey>

where 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<AssetKey, InstrumentKey> Display for Trade<AssetKey, InstrumentKey>

where AssetKey: Display, InstrumentKey: Display,

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

Formats the value using the given formatter.

impl<AssetKey: Eq, InstrumentKey: Eq> Eq for Trade<AssetKey, InstrumentKey>

impl<ExchangeKey, AssetKey, InstrumentKey> From<Trade<AssetKey, InstrumentKey>> for AccountEventKind<ExchangeKey, AssetKey, InstrumentKey>

fn from(value: Trade<AssetKey, InstrumentKey>) -> Self

Converts to this type from the input type.

impl<AssetKey: Hash, InstrumentKey: Hash> Hash for Trade<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<AssetKey: Ord, InstrumentKey: Ord> Ord for Trade<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<AssetKey: PartialEq, InstrumentKey: PartialEq> PartialEq for Trade<AssetKey, InstrumentKey>

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

Equality operator ==.

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

Inequality operator !=.

impl<AssetKey: PartialOrd, InstrumentKey: PartialOrd> PartialOrd for Trade<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<AssetKey, InstrumentKey> Serialize for Trade<AssetKey, InstrumentKey>

where 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<AssetKey: PartialEq, InstrumentKey: PartialEq> StructuralPartialEq for Trade<AssetKey, InstrumentKey>