Struct FuturesPosition

#[repr(align(64))]
pub struct FuturesPosition {

    pub id: PositionId,
    pub venue: Venue,
    pub symbol: String,
    pub side: PositionSide,
    pub amount: Decimal,
    pub entry_price: Decimal,
    pub breakeven_price: Decimal,
    pub unrealized_pnl: Decimal,
    pub realized_pnl: Decimal,
    pub margin_type: MarginType,
    pub isolated_wallet: Decimal,
    pub creation_time_ns: u64,
    pub update_time_ns: u64,
    pub metadata: Value,
}

Represents a futures position in the system

Fields

id: PositionId

Unique position ID

venue: Venue

Exchange identifier

symbol: String

Trading symbol (e.g. “BTCUSDT”)

side: PositionSide

Position side (long/short/both)

amount: Decimal

Position amount (positive for long, negative for short in unified margin)

entry_price: Decimal

Entry price

breakeven_price: Decimal

Breakeven price

unrealized_pnl: Decimal

Unrealized PnL

realized_pnl: Decimal

Accumulated realized PnL

margin_type: MarginType

Margin type

isolated_wallet: Decimal

Isolated wallet amount (for isolated margin)

creation_time_ns: u64

Position creation time in nanoseconds

update_time_ns: u64

Position update time in nanoseconds

metadata: Value

Additional position metadata

Implementations

impl FuturesPosition

pub fn new( venue: Venue, symbol: impl AsRef<str>, side: PositionSide, amount: Decimal, entry_price: Decimal, margin_type: MarginType, ) -> Self

Create a new futures position

pub fn update( &mut self, amount: Decimal, entry_price: Decimal, breakeven_price: Decimal, unrealized_pnl: Decimal, realized_pnl: Decimal, isolated_wallet: Decimal, )

Update position with new data from exchange position reports

This method performs a complete update of all mutable position fields based on fresh data received from the exchange. It’s designed for high-frequency updates where position state changes rapidly.

Parameters

• amount - New position size (positive for long, negative for short in unified margin)
• entry_price - Updated average entry price after fills or position adjustments
• breakeven_price - Price at which the position breaks even (includes fees)
• unrealized_pnl - Current unrealized profit/loss at market price
• realized_pnl - Accumulated realized profit/loss from closed portions
• isolated_wallet - Available margin for isolated positions (0 for cross margin)

Field Mutations

This method updates the following fields:

• amount: Position size with sign indicating direction
• entry_price: Average entry price (weighted by fills)
• breakeven_price: Break-even price including fees and funding
• unrealized_pnl: Mark-to-market P&L at current price
• realized_pnl: Cumulative realized P&L from position reductions
• isolated_wallet: Margin available for isolated positions
• update_time_ns: Automatically set to current nanosecond timestamp

Performance Notes

• Cache-line aligned struct (#[repr(align(64))]) for optimal memory access
• Uses high-precision Decimal arithmetic for financial calculations
• Nanosecond timestamp precision for HFT latency tracking
• Designed for frequent updates in high-frequency trading scenarios

Example

let mut position = FuturesPosition::new(/*...*/);

// Update with fresh exchange data
position.update(
    dec!(1.5),      // New position size
    dec!(50200.0),  // Updated entry price
    dec!(50250.0),  // Break-even price
    dec!(750.0),    // Unrealized P&L
    dec!(100.0),    // Realized P&L
    dec!(1000.0),   // Isolated wallet
);

pub const fn is_closed(&self) -> bool

Check if position is closed (amount is zero)

pub fn get_notional_value(&self, current_price: Decimal) -> Decimal

Get position value at current price

pub fn get_pnl(&self, current_price: Decimal) -> Decimal

Get position PnL at current price

Trait Implementations

impl Clone for FuturesPosition

fn clone(&self) -> FuturesPosition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FuturesPosition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FuturesPosition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for FuturesPosition

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

where __S: Serializer,

Serialize this value into the given Serde serializer.