Struct Position 

#[repr(C)]
pub struct Position {

    pub events: Vec<OrderFilled>,
    pub adjustments: Vec<PositionAdjusted>,
    pub trader_id: TraderId,
    pub strategy_id: StrategyId,
    pub instrument_id: InstrumentId,
    pub id: PositionId,
    pub account_id: AccountId,
    pub opening_order_id: ClientOrderId,
    pub closing_order_id: Option<ClientOrderId>,
    pub entry: OrderSide,
    pub side: PositionSide,
    pub signed_qty: f64,
    pub quantity: Quantity,
    pub peak_qty: Quantity,
    pub price_precision: u8,
    pub size_precision: u8,
    pub multiplier: Quantity,
    pub is_inverse: bool,
    pub is_currency_pair: bool,
    pub instrument_class: InstrumentClass,
    pub base_currency: Option<Currency>,
    pub quote_currency: Currency,
    pub settlement_currency: Currency,
    pub ts_init: UnixNanos,
    pub ts_opened: UnixNanos,
    pub ts_last: UnixNanos,
    pub ts_closed: Option<UnixNanos>,
    pub duration_ns: u64,
    pub avg_px_open: f64,
    pub avg_px_close: Option<f64>,
    pub realized_return: f64,
    pub realized_pnl: Option<Money>,
    pub trade_ids: AHashSet<TradeId>,
    pub buy_qty: Quantity,
    pub sell_qty: Quantity,
    pub commissions: IndexMap<Currency, Money>,
}

Represents a position in a market.

The position ID may be assigned at the trading venue, or can be system generated depending on a strategies OMS (Order Management System) settings.

Fields

events: Vec<OrderFilled>

adjustments: Vec<PositionAdjusted>

trader_id: TraderId

strategy_id: StrategyId

instrument_id: InstrumentId

id: PositionId

account_id: AccountId

opening_order_id: ClientOrderId

closing_order_id: Option<ClientOrderId>

entry: OrderSide

side: PositionSide

signed_qty: f64

quantity: Quantity

peak_qty: Quantity

price_precision: u8

size_precision: u8

multiplier: Quantity

is_inverse: bool

is_currency_pair: bool

instrument_class: InstrumentClass

base_currency: Option<Currency>

quote_currency: Currency

settlement_currency: Currency

ts_init: UnixNanos

ts_opened: UnixNanos

ts_last: UnixNanos

ts_closed: Option<UnixNanos>

duration_ns: u64

avg_px_open: f64

avg_px_close: Option<f64>

realized_return: f64

realized_pnl: Option<Money>

trade_ids: AHashSet<TradeId>

buy_qty: Quantity

sell_qty: Quantity

commissions: IndexMap<Currency, Money>

Implementations

impl Position

pub fn new(instrument: &InstrumentAny, fill: OrderFilled) -> Self

Creates a new Position instance.

Panics

This function panics if:

• The instrument.id() does not match the fill.instrument_id.
• The fill.order_side is NoOrderSide.
• The fill.position_id is None.

pub fn purge_events_for_order(&mut self, client_order_id: ClientOrderId)

Purges all order fill events for the given client order ID and recalculates derived state.

Warning

This operation recalculates the entire position from scratch after removing the specified order’s fills. This is an expensive operation and should be used sparingly.

Panics

Panics if after purging, no fills remain and the position cannot be reconstructed.

pub fn apply(&mut self, fill: &OrderFilled)

Applies an OrderFilled event to this position.

Panics

Panics if the fill.trade_id is already present in the position’s trade_ids.

pub fn apply_adjustment(&mut self, adjustment: PositionAdjusted)

Applies a position adjustment event.

This method handles adjustments to position quantity or realized PnL that occur outside of normal order fills, such as:

• Commission adjustments in base currency (crypto spot markets).
• Funding payments (perpetual futures).

The adjustment event is stored in the position’s adjustment history for full audit trail.

Panics

Panics if the adjustment’s quantity_change cannot be converted to f64.

pub fn calculate_pnl( &self, avg_px_open: f64, avg_px_close: f64, quantity: Quantity, ) -> Money

Calculates profit and loss from the given prices and quantity.

pub fn total_pnl(&self, last: Price) -> Money

Returns total P&L (realized + unrealized) based on the last price.

pub fn unrealized_pnl(&self, last: Price) -> Money

Returns unrealized P&L based on the last price.

pub fn closing_order_side(&self) -> OrderSide

Returns the order side required to close this position.

pub fn is_opposite_side(&self, side: OrderSide) -> bool

Returns whether the given order side is opposite to the position entry side.

pub fn symbol(&self) -> Symbol

Returns the instrument symbol.

pub fn venue(&self) -> Venue

Returns the trading venue.

pub fn event_count(&self) -> usize

Returns the count of order fill events applied to this position.

pub fn client_order_ids(&self) -> Vec<ClientOrderId>

Returns unique client order IDs from all fill events, sorted.

pub fn venue_order_ids(&self) -> Vec<VenueOrderId>

Returns unique venue order IDs from all fill events, sorted.

pub fn trade_ids(&self) -> Vec<TradeId>

Returns unique trade IDs from all fill events, sorted.

pub fn notional_value(&self, last: Price) -> Money

Calculates the notional value based on the last price.

Panics

Panics if self.base_currency is None, or if last is not a positive price for inverse instruments.

pub fn last_event(&self) -> Option<OrderFilled>

Returns the last OrderFilled event for the position (if any after purging).

pub fn last_trade_id(&self) -> Option<TradeId>

Returns the last TradeId for the position (if any after purging).

pub fn is_long(&self) -> bool

Returns whether the position is long (positive quantity).

pub fn is_short(&self) -> bool

Returns whether the position is short (negative quantity).

pub fn is_open(&self) -> bool

Returns whether the position is currently open (has quantity and no close timestamp).

pub fn is_closed(&self) -> bool

Returns whether the position is closed (flat with a close timestamp).

pub fn signed_decimal_qty(&self) -> Decimal

Returns the signed quantity as a Decimal.

Uses the raw signed_qty field to preserve full precision, as the quantity field may have reduced precision based on the instrument’s size_precision.

pub fn commissions(&self) -> Vec<Money>

Returns the cumulative commissions for the position as a vector.

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Position

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Position

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Position

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

Formats the value using the given formatter.

impl Eq for Position

impl Hash for Position

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 PartialEq for Position

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Position

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

where __S: Serializer,

Serialize this value into the given Serde serializer.