Struct FuturePosition 

pub struct FuturePosition {
    pub symbol: String,
    pub quantity: Positive,
    pub entry_price: Positive,
    pub side: Side,
    pub expiration_date: ExpirationDate,
    pub contract_size: Positive,
    pub initial_margin_req: Positive,
    pub maintenance_margin_req: Positive,
    pub date: DateTime<Utc>,
    pub fees: Positive,
}

Represents a futures contract position.

Futures are standardized contracts traded on exchanges that obligate the buyer to purchase (or seller to sell) an asset at a predetermined price on a specific future date.

Fields

• symbol - Contract symbol (e.g., “ES”, “CL”, “BTC-QUARTERLY”)
• quantity - Number of contracts
• entry_price - Average entry price
• side - Long or Short position
• expiration_date - Contract expiry date
• contract_size - Multiplier (e.g., 50 for ES, 1000 for CL)
• initial_margin - Initial margin requirement
• maintenance_margin - Maintenance margin level
• date - Position open timestamp
• fees - Commission and exchange fees

Fields

symbol: String

Contract symbol (e.g., “ES”, “CL”, “GC”).

quantity: Positive

Number of contracts held.

entry_price: Positive

Average entry price per contract.

side: Side

Position direction (Long or Short).

expiration_date: ExpirationDate

Contract expiration date.

contract_size: Positive

Contract size multiplier (notional per point).

initial_margin_req: Positive

Initial margin requirement per contract.

maintenance_margin_req: Positive

Maintenance margin requirement per contract.

date: DateTime<Utc>

Timestamp when the position was opened.

fees: Positive

Total trading fees paid.

Implementations

impl FuturePosition

pub fn new( symbol: String, quantity: Positive, entry_price: Positive, side: Side, expiration_date: ExpirationDate, contract_size: Positive, initial_margin_req: Positive, maintenance_margin_req: Positive, date: DateTime<Utc>, fees: Positive, ) -> Self

Creates a new futures position.

Arguments

• symbol - Contract symbol
• quantity - Number of contracts
• entry_price - Average entry price
• side - Long or Short
• expiration_date - Contract expiry
• contract_size - Contract multiplier
• initial_margin_req - Initial margin per contract
• maintenance_margin_req - Maintenance margin per contract
• date - Position open timestamp
• fees - Trading fees

pub fn long( symbol: String, quantity: Positive, entry_price: Positive, expiration_date: ExpirationDate, contract_size: Positive, margin: Positive, ) -> Self

Creates a long futures position with default settings.

Arguments

• symbol - Contract symbol
• quantity - Number of contracts
• entry_price - Entry price
• expiration_date - Contract expiry
• contract_size - Contract multiplier
• margin - Margin requirement

pub fn short( symbol: String, quantity: Positive, entry_price: Positive, expiration_date: ExpirationDate, contract_size: Positive, margin: Positive, ) -> Self

Creates a short futures position with default settings.

Arguments

• symbol - Contract symbol
• quantity - Number of contracts
• entry_price - Entry price
• expiration_date - Contract expiry
• contract_size - Contract multiplier
• margin - Margin requirement

pub fn notional_value_at_entry(&self) -> Result<Positive, PositionError>

Returns the notional value of the position at entry.

Notional = quantity × entry_price × contract_size

Errors

Returns PositionError::PositiveError when the product leaves the Positive range. The three factors are pub fields, so nothing bounds it; Positive * Positive aborted on it (#788).

pub fn notional_value_at_price( &self, current_price: Positive, ) -> Result<Positive, PositionError>

Returns the notional value at a given price.

Arguments

• current_price - Current market price

Errors

Returns PositionError::PositiveError when the product leaves the Positive range (#788).

pub fn unrealized_pnl( &self, current_price: Positive, ) -> Result<Decimal, PositionError>

Calculates the unrealized P&L at a given price.

Arguments

• current_price - Current market price

Decision (issue #471): fallible because pnl_at_price is

This is the whole body of LegAble::pnl_at_price for a future, so leaving it infallible would have moved that method’s abort one frame down rather than removing it. entry_price, quantity and contract_size are pub, so no constructor guard bounds the product.

Errors

Returns PositionError::DecimalError when the price difference, the quantity scaling or the contract-size scaling leaves the representable Decimal range.

pub fn tick_value(&self, tick_size: Positive) -> Result<Positive, PositionError>

Calculates the tick value (value of one minimum price movement).

Arguments

• tick_size - Minimum price increment

Errors

Returns PositionError::PositiveError when the product leaves the Positive range (#788).

pub fn total_margin_required(&self) -> Result<Positive, PositionError>

Returns the total margin required for this position.

Errors

Returns PositionError::PositiveError when the product leaves the Positive range (#788).

pub fn basis(&self, spot_price: Positive) -> Decimal

Calculates the basis (futures price - spot price).

Arguments

• spot_price - Current spot price of the underlying

pub fn implied_leverage(&self) -> Result<Decimal, PositionError>

Calculates the implied leverage of the position.

Leverage = Notional Value / Margin Required, and zero when no margin is required.

Errors

Returns PositionError when the notional, the margin or their ratio leaves the representable range (#788).

Trait Implementations

impl Clone for FuturePosition

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComposeSchema for FuturePosition

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for FuturePosition

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

Formats the value using the given formatter.

impl Default for FuturePosition

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FuturePosition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FuturePosition

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

Formats the value using the given formatter.

impl Expirable for FuturePosition

fn expiration_timestamp(&self) -> Result<i64, PositionError>

Returns the expiration date as a Unix timestamp in seconds.

fn days_to_expiration(&self) -> Result<Positive, PositionError>

Returns the number of days until expiration.

fn is_expired(&self) -> Result<bool, PositionError>

Checks if the position has expired.

fn time_to_expiration_years(&self) -> Result<Decimal, PositionError>

Returns the time to expiration in years (for pricing calculations).

impl From<FuturePosition> for Leg

fn from(position: FuturePosition) -> Self

Converts to this type from the input type.

impl LegAble for FuturePosition

fn get_symbol(&self) -> &str

Returns the symbol/ticker of the underlying instrument.

fn get_quantity(&self) -> Positive

Returns the position quantity in the leg’s native unit (#830).

fn get_side(&self) -> Side

Returns the position side (Long or Short).

fn pnl_at_price(&self, price: Positive) -> Result<Decimal, PositionError>

Calculates the profit/loss at a given price.

fn total_cost(&self) -> Result<Positive, PositionError>

Returns the total cost to establish this position.

fn fees(&self) -> Result<Positive, PositionError>

Returns the total fees associated with this position.

fn is_long(&self) -> bool

Checks if this is a long position.

fn is_short(&self) -> bool

Checks if this is a short position.

fn notional_value(&self, price: Positive) -> Result<Positive, PositionError>

Returns the notional value of the position at a given price.

impl Marginable for FuturePosition

fn liquidation_price( &self, _current_price: Positive, ) -> Result<Option<Positive>, PositionError>

None for a long whose margin buffer per unit exceeds the entry price: no non-negative price liquidates it. A short threshold below zero is floored at zero, the documented domain floor of Marginable::liquidation_price.

Errors

Returns PositionError::DecimalError for a zero quantity or contract size, where the buffer per unit is undefined (the division aborted with Division by zero, #788), and when a margin, the buffer or the shifted price leaves the representable range.

fn initial_margin(&self) -> Result<Positive, PositionError>

Returns the initial margin requirement.

fn maintenance_margin(&self) -> Result<Positive, PositionError>

Returns the maintenance margin requirement.

fn leverage(&self) -> Result<Positive, PositionError>

Returns the current leverage applied to the position.

fn is_liquidation_risk( &self, current_price: Positive, _margin_ratio: Decimal, ) -> Result<bool, PositionError>

Checks if the position is at risk of liquidation.

impl PartialEq for FuturePosition

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for FuturePosition

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 FuturePosition

impl ToSchema for FuturePosition

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.